Aritmética y concatenación: el catálogo completo y la regla de selección

Una metatabla es la tabla de respuestas que Lua consulta cuando una operación no tiene sentido con los valores que recibe. Toca abrir el catálogo entero, y el bloque más grande es el de la aritmética, los operadores de bits y la concatenación: quince eventos, quince nombres. Aquí no hay magia, hay un algoritmo de dos pasos que puedes recitar de memoria, y una consecuencia incómoda que casi nadie anticipa: como Lua interroga primero al operando de la izquierda, el metamétodo que acaba ejecutándose puede pertenecer a un tipo que no sabe nada del otro. El diseño de tus operadores empieza por asumir esa asimetría, no por ignorarla.

El catálogo

Cada operador del lenguaje tiene un nombre de evento, y ese nombre es la clave que Lua busca en la metatabla. Son claves normales de una tabla normal: el guion bajo doble es convención tipográfica, no sintaxis privilegiada.

Los dos unarios, __unm y __bnot, reciben el mismo valor duplicado en sus dos parámetros. No es un descuido de la implementación: uniformar la aridad permite que el intérprete llame a todos los metamétodos binarios con el mismo código, y a ti te permite escribir la función ignorando el segundo argumento.

Cómo elige Lua

Para una operación binaria, Lua sigue siempre el mismo procedimiento. Primero comprueba si los operandos son válidos de forma nativa: números para la aritmética, enteros para los bits, cadenas o números para la concatenación. Si lo son, ejecuta la operación de máquina y no mira ninguna metatabla. Si no lo son, empieza la búsqueda del metamétodo, y aquí está la regla que hay que grabarse: mira la metatabla del primer operando; si no define el evento, mira la del segundo.

flowchart TB
A[Lua evalua a mas b] --> B[Son ambos operandos validos de forma nativa]
B --> C[Si lo son ejecuta la operacion de maquina]
B --> D[Si no consulta la metatabla del primer operando]
D --> E[Si define el evento lo llama con a y b en ese orden]
D --> F[Si no consulta la metatabla del segundo operando]
F --> E
F --> G[Si tampoco lo define lanza error de aritmetica]

La consecuencia es doble. La primera: el metamétodo recibe siempre los operandos en el orden original, aunque lo hayan encontrado por el lado derecho. En 2 * v, si el vector aporta el __mul, la función se llama con el número como primer argumento. La segunda: no existe nada parecido a un metamétodo reflejado, esa segunda función que otros lenguajes invocan cuando el objeto está a la derecha. Aquí solo hay una función, y su primera responsabilidad es averiguar cuál de los dos argumentos es de su tipo.

Un vector que sobrevive al orden

El ejemplo canónico es un vector de dos componentes. Fíjate en __mul: normaliza el orden antes de operar, que es el patrón que todo metamétodo binario debería seguir.

local Vec = {}
Vec.__index = Vec

local function nuevo(x, y)
  return setmetatable({ x = x, y = y }, Vec)
end

local function esVec(v)
  return getmetatable(v) == Vec
end

function Vec.__add(a, b)
  if not (esVec(a) and esVec(b)) then
    error("solo se suman vectores entre si", 2)
  end
  return nuevo(a.x + b.x, a.y + b.y)
end

function Vec.__unm(v)                 -- Lua pasa v dos veces; usamos el primero
  return nuevo(-v.x, -v.y)
end

function Vec.__mul(a, b)              -- escalar por vector o vector por escalar
  if type(a) == "number" then a, b = b, a end
  if not (esVec(a) and type(b) == "number") then
    error("el producto admite un vector y un escalar", 2)
  end
  return nuevo(a.x * b, a.y * b)
end

function Vec.__concat(a, b)
  return tostring(a) .. tostring(b)
end

function Vec.__tostring(v)
  return string.format("vec[%g, %g]", v.x, v.y)
end

local v = nuevo(1, 2)
print(v + nuevo(3, 4))   -- vec[4, 6]
print(2 * v)             -- vec[2, 4]  el escalar viene primero
print(v * 2)             -- vec[2, 4]  y aqui viene segundo
print(-v)                -- vec[-1, -2]

El truco de a, b = b, a cuesta una línea y elimina toda una clase de errores. Sin él, 2 * v intentaría leer a.x sobre un número y fallaría con un mensaje que no ayuda a nadie.

La trampa de los dos tipos

¿Qué pasa cuando los dos operandos tienen metatabla y ambos definen el mismo evento? La respuesta es tajante: gana el de la izquierda, siempre. Si sumas un vector y un número complejo de otra biblioteca, se ejecuta el __add del vector, que recibe un objeto que no reconoce. No hay negociación, no hay reintento con el otro operando, no hay valor especial que puedas devolver para decir este caso no es mío. O tu metamétodo sabe qué hacer con lo que le llega, o lanza un error decente.

De ahí la disciplina: valida siempre los dos argumentos y falla con error y nivel 2, para que el mensaje señale la línea de quien escribió la operación y no la de tu biblioteca.