Constructores de tabla

El constructor de tabla es la construcción sintáctica más densa de Lua: en un solo par de llaves conviven tres notaciones distintas, una regla de numeración implícita, un azúcar sintáctico que oculta una conversión a cadena y una excepción sobre la última expresión que provoca más sorpresas que ninguna otra regla del lenguaje. Aprenderlo bien no es aprender a escribir literales bonitos, sino entender exactamente qué claves acaban existiendo, con qué valores y en qué orden se evalúan.

Las tres notaciones

Un constructor es un par de llaves con cero o más campos separados por coma o por punto y coma. Cada campo puede escribirse de una de tres formas:

-- Forma de lista: solo el valor. Lua asigna 1, 2, 3... en orden
local a = { "rojo", "verde", "azul" }
-- equivale a: a[1]="rojo"; a[2]="verde"; a[3]="azul"

-- Forma de mapa: nombre = valor. La clave es la cadena con ese nombre
local b = { ancho = 80, alto = 24 }
-- equivale a: b["ancho"]=80; b["alto"]=24

-- Forma con corchetes: [expresion] = valor. La clave es cualquier valor
local k = "din" .. "amica"
local c = { [k] = 1, [10] = "diez", [true] = "si", [1.5] = "medio" }

La forma de mapa es estrictamente menos general que la de corchetes: nombre = v es azúcar de ["nombre"] = v. La consecuencia es que solo admite claves que sean identificadores válidos de Lua. Una clave con espacios, con guiones, que empiece por dígito o que coincida con una palabra reservada obliga a usar corchetes.

flowchart TD
C[Campo del constructor] --> L[Solo valor]
C --> N[nombre igual valor]
C --> B[Corchetes con expresion]
L --> L1[Recibe el siguiente indice entero implicito]
N --> N1[Azucar de la clave de cadena]
B --> B1[Cualquier valor salvo nil y NaN]

Mezclar notaciones en un mismo literal

Nada impide combinar las tres formas. La regla que hay que interiorizar es que solo los campos de la forma de lista consumen el contador implícito; los otros dos lo ignoran por completo:

local t = {
  "a",              -- t[1] = "a"
  x = 10,           -- t["x"] = 10   (no toca el contador)
  "b",              -- t[2] = "b"
  [100] = "cien",   -- t[100] = "cien" (tampoco toca el contador)
  "c",              -- t[3] = "c"
}

De ahí se sigue un choque que conviene conocer: si un campo con corchetes escribe en un índice entero que el contador implícito también va a usar, gana el que se evalúe después, y el orden de evaluación de los campos es de arriba abajo.

local u = { [1] = "puesto a mano", "posicional" }
print(u[1])  --> posicional   (el campo de lista se evalua despues)

Esa última regla merece verse, porque explica el aspecto de casi todos los archivos de configuración escritos en Lua, incluidos los de los gestores de complementos de editores modernos:

local function ventana(opts) return opts.ancho * opts.alto end
print(ventana{ ancho = 80, alto = 24 })   -- sin parentesis: azucar de llamada

Los constructores anidan sin límite, y ese anidamiento es lo que convierte un literal en un árbol de datos completo. Como los valores pueden ser funciones, el árbol puede llevar comportamiento dentro, algo que ningún formato de datos puro permite:

local plugin = {
  nombre = "buscador",
  dependencias = { "plenary", "telescope" },
  opciones = {
    ventana = { borde = "redondeado", ancho = 0.8 },
    atajos  = {
      { modo = "n", tecla = "ff", accion = "buscar_archivos" },
      { modo = "n", tecla = "fg", accion = "buscar_texto" },
    },
  },
  al_cargar = function(self) return "cargado " .. self.nombre end,
}

Obsérvese que el campo atajos es una secuencia de registros: la forma de lista en el nivel exterior y la de mapa en el interior. Esa combinación —lista de tablas con campos con nombre— es, con diferencia, la estructura más frecuente en la configuración de programas reales escritos en Lua.

La regla de la última expresión

Aquí está la sutileza que más sorprende. Cuando una llamada a función o el operador de puntos suspensivos aparece como último campo de la forma de lista, se expande a todos sus valores de retorno. En cualquier otra posición, se recorta a uno solo:

local function tres() return "a", "b", "c" end

local x = { tres() }          -- #x == 3   : expande
local y = { tres(), "z" }     -- #y == 2   : recorta a "a", luego "z"
local z = { (tres()) }        -- #z == 1   : los parentesis fuerzan un valor

La misma regla vale para el parámetro variádico dentro de una función, y de ahí nace uno de los idiomas más usados del lenguaje: empaquetar los argumentos recibidos en una tabla.

local function registrar(...)
  local args = { ... }        -- ultima expresion: expande todo
  return #args
end