Las funciones son valores: declarar es asignar

Casi todos los lenguajes que has usado tratan las funciones como una categoría aparte. Hay declaraciones, que ocurren en tiempo de compilación y viven en un espacio propio, y hay variables, que ocurren en tiempo de ejecución y guardan datos. Lua no hace esa distinción en ningún punto de su semántica. Una función es un valor exactamente en el mismo sentido en que lo es el número siete: se crea evaluando una expresión, se guarda donde quieras, se copia, se pasa, se devuelve, se compara por identidad, se usa como clave de una tabla y se descarta cuando el recolector deja de encontrarle referencias. Esta lección abre el nivel entero desmontando la pieza de azúcar sintáctico que oculta ese hecho, porque hasta que no ves la asignación escondida detrás de la palabra function con nombre, la mitad de los idiomas de Lua parecen magia arbitraria en lugar de lo que realmente son: consecuencias inevitables de que aquí no haya nada especial en una función.

Declarar es asignar

La expresión primitiva del lenguaje es la función anónima: la palabra function, una lista de parámetros entre paréntesis, un cuerpo y la palabra end. Eso es una expresión, y evaluarla produce un valor nuevo. Todo lo demás que parece una declaración es una abreviatura de asignar ese valor a algún sitio, y las abreviaturas están definidas en el manual de referencia como transformaciones puramente sintácticas.

-- La forma primitiva: una expresion que produce un valor
local doble = function(n) return n * 2 end

-- El azucar con nombre: identico a la linea de arriba
local function doble(n) return n * 2 end

-- Sin local, la asignacion va a una variable global
function triple(n) return n * 3 end
-- equivale a:  triple = function(n) return n * 3 end

-- Y como es un valor, se comporta como cualquier otro valor
local alias = doble
print(type(doble))        --> function
print(alias == doble)     --> true, es el mismo valor
print(alias(21))          --> 42

-- Dos evaluaciones de la misma sintaxis producen valores distintos
local a = function() end
local b = function() end
print(a == b)             --> false

Merece la pena detenerse en las dos últimas líneas, porque revelan que no estamos ante nombres sino ante objetos. Cada vez que el flujo de ejecución pasa por una expresión function se crea un valor nuevo, con su propia identidad. Si esa expresión está dentro de un bucle, el bucle fabrica una función distinta en cada vuelta. Esto no es un detalle académico: es la base de los closures del nivel siguiente y la causa de que las funciones creadas dentro de un bucle capturen variables distintas.

Campos de tabla: el módulo, el objeto y el espacio de nombres

Si una función es un valor, puede ser el valor asociado a una clave de una tabla. Ahí termina, literalmente, toda la teoría de módulos y objetos de Lua. Un módulo es una tabla cuyos campos son funciones. Un objeto es una tabla cuyos campos son funciones. Un espacio de nombres es una tabla cuyos campos son funciones. No hay tres mecanismos, hay uno, y la diferencia entre los tres es únicamente qué haces con la tabla después.

-- Construida a mano, campo a campo
local geometria = {}
geometria.area = function(r) return math.pi * r * r end
geometria.perimetro = function(r) return 2 * math.pi * r end

-- El azucar con punto: mismo resultado
function geometria.diametro(r) return 2 * r end

-- Tambien en el constructor de tabla, todo de una vez
local vector = {
  cero  = function() return 0, 0 end,
  sumar = function(ax, ay, bx, by) return ax + bx, ay + by end,
}

-- Y anidado a cualquier profundidad
local app = { util = { texto = {} } }
function app.util.texto.recortar(s) return (s:gsub("^%s+", "")) end

-- La tabla no sabe que contiene funciones: son campos como cualquier otro
for clave, valor in pairs(geometria) do
  print(clave, type(valor))
end

Nada de esto requiere una palabra clave de módulo ni un sistema de clases. El fichero de un módulo suele crear una tabla local, rellenarla de funciones y devolverla con return; quien lo carga con require recibe esa tabla y accede a los campos. El resultado es que exportar es asignar y que importar es leer un campo, sin ninguna maquinaria intermedia.

El matiz de local function y la recursión

Aquí aparece la única asimetría real del capítulo, y es importante porque explica un fallo que desconcierta a quien la desconoce. La forma local con nombre no se traduce como una asignación local corriente: se traduce como una declaración de la variable local seguida de la asignación, en dos pasos.

-- Esto NO compila como esperarias
local factorial = function(n)
  if n <= 1 then return 1 end
  return n * factorial(n - 1)   -- factorial aqui es la GLOBAL, aun nil
end

-- La forma con nombre declara primero y asigna despues
local function factorial(n)
  if n <= 1 then return 1 end
  return n * factorial(n - 1)   -- ahora si: la local ya existe
end

-- Equivalencia exacta de la forma con nombre
local factorial
factorial = function(n)
  if n <= 1 then return 1 end
  return n * factorial(n - 1)
end

-- Para recursion mutua hay que declarar las dos antes
local par, impar
function par(n)   if n == 0 then return true  else return impar(n - 1) end end
function impar(n) if n == 0 then return false else return par(n - 1)   end end

El motivo es de ámbito léxico, no de funciones. En la primera versión, el cuerpo se compila antes de que la variable local exista, de modo que el nombre se resuelve como global y en tiempo de ejecución vale nil. La forma con nombre existe precisamente para que el caso más común, la recursión directa, funcione sin obligarte a escribir la declaración previa a mano.

flowchart LR
A[Expresion function] --> B[Valor de tipo funcion]
B --> C[Variable local]
B --> D[Variable global]
B --> E[Campo de tabla]
B --> F[Argumento o retorno]
style B fill:#a6e3a1,color:#11111b
style E fill:#89b4fa,color:#11111b