Iteradores sin estado: cuando la posición cabe en la tripleta

Hay una categoría de iteradores que no asigna memoria, no crea closures, no toca el recolector y puede compartirse entre todos los bucles del programa a la vez, incluso desde varias corrutinas simultáneas. Se llaman iteradores sin estado y su definición es puramente negativa: no guardan nada entre llamadas. Lo consiguen porque no lo necesitan, y no lo necesitan porque el for genérico ya les devuelve la posición en cada vuelta, empaquetada en la variable de control. Entender esta clase es entender qué papel juegan de verdad los dos argumentos que recibe la función iteradora, y descubrir que la mayor parte de los recorridos que uno escribe a mano con closures podrían haberse escrito sin ninguno. Los dos iteradores más usados de la biblioteca básica, next y el contador interno de ipairs, pertenecen a esta categoría, y no por casualidad.

La condición: la posición cabe en un valor

La función iteradora recibe siempre dos argumentos, el estado invariante y la variable de control, y el bucle actualiza el segundo con el primer valor que ella devuelve. Un iterador es sin estado cuando esos dos argumentos bastan para calcular la vuelta siguiente, sin consultar ni modificar nada más.

Formalmente es una función pura: para el mismo par de argumentos devuelve siempre lo mismo. Y de esa pureza se sigue todo lo demás. Puede ser un valor único creado una sola vez al cargar el módulo, porque no hay nada que particularizar por bucle. Puede usarse desde dos bucles anidados sobre la misma estructura sin interferencias, porque cada bucle lleva su propia variable de control. Y no cuesta ni una asignación de memoria, porque construir la tripleta es devolver tres valores que ya existen.

local function siguiente(n, i)   -- estado: el limite; control: el ultimo entero
  i = i + 1
  if i <= n then return i end
end

local function hasta(n)
  return siguiente, n, 0         -- ni un solo objeto nuevo por bucle
end

for i in hasta(4) do print(i) end

La condición práctica que hay que comprobar antes de intentarlo es una sola: la posición del recorrido debe caber en un valor. Un índice cabe. Un nodo de una lista cabe. Un par de coordenadas no cabe tal cual, pero sí cabe codificado en un entero si conoces la anchura. Una posición dentro de un flujo de red que no puede rebobinarse no cabe de ninguna manera, y ahí es donde empieza la lección siguiente.

Coste cero por bucle

La diferencia de coste frente a un iterador con closure no está en la llamada, que es idéntica, sino en la preparación. Cada evaluación de la lista de expresiones de un for con closure crea al menos un objeto nuevo, con su asignación de memoria y su futura visita del recolector. Un iterador sin estado no crea ninguno.

flowchart TD
A[Entrar en el bucle] --> B[Evaluar la lista de expresiones]
B --> C[Iterador sin estado devuelve tres valores existentes]
B --> D[Iterador con estado crea un closure nuevo]
C --> E[Cero asignaciones y cero presion sobre el recolector]
D --> F[Una asignacion por bucle mas sus upvalues]
E --> G[Llamadas por vuelta identicas en ambos casos]
F --> G

Esa asimetría es irrelevante en un bucle que se ejecuta una vez y decisiva en un bucle interno que se entra millones de veces, que es la situación habitual en un motor de juego, un intérprete embebido o un manejador de eventos. La regla de oficio que se deduce es directa: si el recorrido puede escribirse sin estado, escríbelo sin estado, no por microoptimización sino porque suele salir además más simple de leer, ya que obliga a hacer explícito qué constituye una posición.

Dos recorridos propios

El primer caso es una lista enlazada simple. La posición del recorrido es el nodo actual, y un nodo es un valor; así que el iterador puede ser sin estado y ni siquiera necesita el estado invariante.

local Lista = {}

local function siguienteNodo(_, nodo)      -- ignora el estado invariante
  nodo = nodo.sig
  if nodo then return nodo, nodo.valor end -- primero la posicion, luego el dato
end

function Lista.nodos(lista)
  return siguienteNodo, nil, lista         -- la cabecera hace de centinela
end

-- la cabecera lleva el mismo campo sig que los nodos, asi que no hay caso especial
local l = { sig = { valor = "a", sig = { valor = "b" } } }
for nodo, valor in Lista.nodos(l) do print(valor) end

Obsérvese la disciplina del orden de los valores devueltos: el nodo va primero porque es la posición, y el dato va después. Si se invirtiesen, un valor nulo almacenado en la lista cortaría el recorrido, y además el bucle alimentaría la variable de control con un dato en lugar de con una posición, que es la forma más rápida de escribir un iterador que no avanza.

El segundo caso es una matriz guardada en un vector plano, donde la posición son dos coordenadas y hay que codificarlas. La codificación evidente es el propio índice lineal, del que las coordenadas se recuperan con una división entera y un módulo.

local function siguienteCelda(m, k)
  k = k + 1
  if k > m.filas * m.cols then return end
  local f = (k - 1) // m.cols + 1
  local c = (k - 1) % m.cols + 1
  return k, f, c, m.datos[k]      -- posicion, fila, columna, valor
end

local function celdas(m)
  return siguienteCelda, m, 0
end

local m = { filas = 2, cols = 3, datos = { 1, 2, 3, 4, 5, 6 } }
for _, f, c, v in celdas(m) do print(f, c, v) end

Aquí el iterador devuelve cuatro valores y el bucle declara cuatro variables, descartando la primera con el nombre convencional de descarte. Es un patrón que merece reconocerse: cuando la posición no coincide con lo que el consumidor quiere ver, se emite igualmente en primer lugar, porque el protocolo la necesita, y se ignora en el cuerpo.

Las dos fábricas de esta lección, Lista.nodos y celdas, no crean nada: devuelven una función que ya existía desde que se cargó el módulo, un valor que el llamante ya tenía y una constante. Esa es la firma característica de la categoría, y es la comprobación que conviene hacer al terminar de escribir un iterador que se creía sin estado. Si la fábrica construye una tabla, un closure o cualquier objeto, algo se ha colado.