La llamada: paso de argumentos, azúcares y dos puntos

Hay una frase que circula por foros y tutoriales y que conviene desactivar antes de seguir: la de que en Lua los números y las cadenas se pasan por valor y las tablas por referencia. Es falsa, y su falsedad no es una pedantería terminológica sino la raíz de la mitad de las confusiones sobre qué modificaciones sobreviven a una llamada. Lua pasa absolutamente todo por valor, sin una sola excepción. Lo que ocurre es que algunos de sus valores son referencias a estructuras que viven en otro sitio, y copiar una referencia es copiar una dirección, no lo que hay al final de ella. Con ese único ajuste mental se explican de golpe todos los comportamientos que parecían inconsistentes: por qué reasignar un parámetro nunca se ve desde fuera, por qué modificar un campo sí, y por qué las funciones que pretenden vaciar una tabla tienen que borrar sus claves en lugar de asignarle una tabla nueva. Esta lección construye ese modelo y después recorre las tres piezas de azúcar sintáctico que rodean a la llamada, incluida la más famosa de todas, los dos puntos.

Paso por valor, incluso cuando el valor es una referencia

Los ocho tipos de Lua se dividen en dos grupos según lo que la variable guarda. Números, booleanos, cadenas y nil guardan el dato en sí. Tablas, funciones, hilos y userdata guardan una referencia a un objeto del montón. En ambos casos, llamar a una función copia lo que la variable guarda en el parámetro correspondiente. La consecuencia es doble y muy limpia.

local function reasignar(t)
  t = { 99 }          -- solo cambia la COPIA local de la referencia
end

local function mutar(t)
  t[1] = 99           -- sigue la referencia y modifica el objeto compartido
end

local datos = { 1 }
reasignar(datos)  print(datos[1])   --> 1    nada cambio fuera
mutar(datos)      print(datos[1])   --> 99   el objeto era el mismo

-- Vaciar una tabla desde dentro exige tocar el objeto, no la variable
local function vaciar(t)
  for k in pairs(t) do t[k] = nil end
end

-- Las cadenas son inmutables: no hay mutacion posible, solo cadenas nuevas
local function gritar(s)
  s = s:upper()       -- crea otra cadena y la guarda en el parametro
  return s
end

El parámetro es, a todos los efectos, una variable local más de la función, inicializada con el valor del argumento. Asignarle algo nuevo es cambiar esa local y nada más. Seguir la referencia y escribir en el objeto apuntado es otra operación distinta, y es la única que el llamante puede observar.

Aridad: lo que falta y lo que sobra

Lua no comprueba el número de argumentos. Si pasas menos de los declarados, los parámetros restantes valen nil; si pasas más, los sobrantes se descartan sin traza. Este es el mismo ajuste de listas que gobierna los retornos múltiples de la lección anterior, aplicado a la lista de argumentos.

local function saludar(nombre, saludo, signo)
  saludo = saludo or "Hola"           -- idioma canonico de valor por defecto
  signo  = signo  or "!"
  return saludo .. ", " .. nombre .. signo
end

print(saludar("Ada"))                  --> Hola, Ada!
print(saludar("Ada", "Buenas"))        --> Buenas, Ada!
print(saludar("Ada", "Ey", "?", 1, 2)) --> Ey, Ada?   los extras se tiran

-- Cuidado: el idioma con or no distingue nil de false
local function activar(flag)
  if flag == nil then flag = true end  -- forma correcta si false es valido
  return flag
end

-- Y un caso clasico de error mudo: coma de mas, argumento desplazado
-- table.insert(t, 3, valor)  inserta EN LA POSICION 3
-- table.insert(t, valor)     inserta AL FINAL

La tolerancia es cómoda y tiene un coste real: una llamada con los argumentos en orden equivocado, o con uno de menos por un descuido, no falla en el punto de la llamada sino mucho después, cuando alguien intenta usar un nil inesperado. Es el precio de no tener firmas verificadas, y la razón de que las bibliotecas maduras validen sus entradas explícitamente en las funciones públicas.

Los tres azúcares: tabla, cadena y dos puntos

Lua reserva dos abreviaturas para el caso de un único argumento literal, y una tercera para insertar un primer argumento implícito. Las tres son reescrituras puramente sintácticas, sin ninguna semántica propia.

-- Argumento unico que es una tabla literal: los parentesis sobran
crear{ nombre = "mapa", ancho = 64, alto = 64 }
-- equivale a: crear({ nombre = "mapa", ancho = 64, alto = 64 })

-- Argumento unico que es una cadena literal: idem
require "socket"          -- equivale a require("socket")
print "hola"              -- equivale a print("hola")
local re = ("%d+"):rep(2) -- el parentesis es para el literal, no la llamada

-- Dos puntos: inserta el receptor como PRIMER argumento
local cuenta = { saldo = 100 }
function cuenta.ingresar(self, cantidad) self.saldo = self.saldo + cantidad end
cuenta:ingresar(50)         -- equivale a cuenta.ingresar(cuenta, 50)

-- Y en la declaracion, los dos puntos declaran self implicitamente
function cuenta:retirar(cantidad) self.saldo = self.saldo - cantidad end
-- equivale a: function cuenta.retirar(self, cantidad) ... end

-- La trampa clasica: mezclar las dos formas
local metodo = cuenta.ingresar
metodo(cuenta, 10)          -- correcto: self va explicito
-- metodo(10)               -- error: self valdria 10

La abreviatura de tabla literal es la que sostiene el estilo declarativo de innumerables bibliotecas de Lua, desde definiciones de configuración hasta constructores de interfaces, porque permite que una llamada a función parezca un bloque de datos. La de cadena literal es la razón de que require se escriba sin paréntesis en la mayoría del código que verás.

flowchart LR
A[obj dos puntos metodo con args] --> B[obj punto metodo con obj y args]
B --> C[Busqueda de la clave metodo en obj]
C --> D[Llamada normal con self como primer parametro]
E[Llamada con tabla literal] --> F[Llamada normal de un argumento]
style B fill:#a6e3a1,color:#11111b
style D fill:#89b4fa,color:#11111b