Idiomas fundamentales con tablas

Un lenguaje con un único tipo compuesto no tiene bibliotecas de estructuras de datos: tiene idiomas. Un idioma es un patrón de uso de la tabla lo bastante estable como para haberse convertido en vocabulario compartido de la comunidad, reconocible a simple vista y con un coste conocido. Los cuatro que siguen —conjunto, caché, cola y registro de funciones— cubren la inmensa mayoría de las necesidades estructurales de un programa Lua, se escriben en menos de diez líneas cada uno y son la mejor demostración de que la pequeñez del lenguaje no limita lo que puedes construir, solo traslada quién lo construye.

El conjunto: las claves son los elementos

La observación de partida es que una tabla ya es un conjunto de claves. Basta ignorar los valores y usarlos como testigo de presencia para obtener pertenencia en tiempo constante, sin recorrer nada:

local function conjunto(lista)
  local s = {}
  for _, v in ipairs(lista) do s[v] = true end
  return s
end

local reservadas = conjunto{ "if", "then", "else", "end", "local" }

if reservadas["local"] then print("es palabra reservada") end
reservadas["goto"] = true    -- anadir
reservadas["if"] = nil       -- quitar: borrar la clave es quitar del conjunto

Las operaciones clásicas caben en una línea cada una. La unión recorre los dos conjuntos y marca; la intersección recorre el menor y comprueba en el otro; la diferencia recorre el primero y descarta lo que esté en el segundo. Todas son lineales en el tamaño del conjunto recorrido y ninguna necesita ordenar.

La caché con valor por defecto

El segundo idioma resuelve un problema recurrente: consultar una clave que quizá no exista todavía y querer que se fabrique sola. La versión explícita se escribe con una comprobación; la versión elegante delega en la metatabla, cuyo campo de búsqueda fallida recibe la tabla y la clave ausente y puede crear el valor en ese momento.

-- Version explicita: valida en cualquier version de Lua
local function obtener(cache, k)
  local v = cache[k]
  if v == nil then v = calcular(k); cache[k] = v end
  return v
end

-- Version con metatabla: la tabla se rellena sola al consultarla
local memo = setmetatable({}, {
  __index = function(t, k)
    local v = calcular(k)
    t[k] = v          -- se guarda: la proxima consulta ya no entra aqui
    return v
  end,
})

print(memo[10])   -- calcula y almacena
print(memo[10])   -- lectura directa: la busqueda ya no falla

Ese guardado dentro de la propia función es lo que convierte el patrón en una caché real y no en un simple valor por defecto: la búsqueda fallida ocurre una sola vez por clave. La misma idea, con una tabla vacía como valor fabricado, produce el idioma del diccionario anidado automático, donde puedes escribir en un nivel profundo sin crear a mano cada nivel intermedio.

flowchart TD
Q[Consulta de una clave] --> H[Busqueda directa en la tabla]
H --> R[Existe y se devuelve el valor]
H --> M[No existe y hay metatabla con index]
M --> F[La funcion fabricante calcula el valor]
F --> G[Lo guarda en la tabla]
G --> R

La cola con dos índices

Desencolar con table.remove desde la primera posición cuesta lineal, porque compacta el resto. Para una cola con mucho tráfico eso es inaceptable. El idioma canónico mantiene dos índices y no mueve jamás un elemento: encolar avanza la cabeza, desencolar avanza la cola y borra la entrada consumida para que el recolector pueda liberarla.

local Cola = {}

function Cola.nueva() return { primero = 1, ultimo = 0 } end

function Cola.encolar(q, v)
  q.ultimo = q.ultimo + 1
  q[q.ultimo] = v
end

function Cola.desencolar(q)
  if q.primero > q.ultimo then return nil end
  local v = q[q.primero]
  q[q.primero] = nil          -- libera la referencia para el recolector
  q.primero = q.primero + 1
  return v
end

Ambas operaciones son de coste constante y la tabla nunca se compacta. Nótese que la estructura resultante no es una secuencia: sus claves enteras empiezan en un índice que va creciendo, de modo que el operador de longitud y ipairs no significan nada útil sobre ella. El número de elementos es la diferencia entre los dos índices, y eso es deliberado.

El registro de funciones

Como las funciones son valores de primera clase, una tabla puede asociarlas a nombres y sustituir por completo a una cadena de comparaciones. El patrón aparece en despachadores de eventos, en intérpretes de comandos, en gestores de estados y en la práctica totalidad de los complementos de editores escritos en Lua:

local acciones = {
  abrir  = function(arg) return "abriendo " .. arg end,
  cerrar = function(arg) return "cerrando " .. arg end,
  listar = function()    return "listado completo" end,
}

local function despachar(nombre, arg)
  local f = acciones[nombre]
  if not f then return nil, "accion desconocida: " .. nombre end
  return f(arg)
end

La ventaja decisiva no es la brevedad sino que el conjunto de casos deja de ser código y pasa a ser un dato: se puede recorrer para generar ayuda, comprobar antes de llamar, ampliar desde un complemento externo o filtrar por permisos, todo sin tocar el despachador. Es el mismo mecanismo con el que los módulos de la biblioteca estándar se exponen, y la razón por la que en Lua ampliar un programa rara vez exige modificarlo.