El paso de valores: cuatro canales y una doble dirección

Casi todo el mundo entiende resume y yield a la primera y casi nadie acierta con el paso de valores a la primera. La razón es que yield es la única construcción del lenguaje que mira simultáneamente hacia dentro y hacia fuera: sus argumentos salen del cómputo y sus valores de retorno entran en él, y ambas cosas ocurren en el mismo punto del texto pero en momentos separados por una suspensión que puede durar lo que quiera. Sumado a que el primer resume no se comporta como los demás, tenemos cuatro canales de comunicación distintos y un desfase de uno entre reanudaciones y cesiones. Esta lección desmonta la maraña canal por canal.

Cuatro canales de comunicación

Entre la corrutina y quien la reanuda circulan valores en dos direcciones, y en cada dirección hay dos puertas distintas según sea la primera vez o no. Conviene fijar los cuatro casos con nombre propio antes de mirar ningún código.

Los cuatro admiten un número arbitrario de valores, incluido cero, y ninguno impone ninguna correspondencia con los demás. Puedes reanudar con tres valores y recibir cero; ceder con cero y ser reanudado con siete. No hay firma, no hay comprobación y no hay ayuda del lenguaje: el protocolo entre las dos partes lo estableces tú y no lo vigila nadie.

sequenceDiagram
participant P as Principal
participant C as Corrutina
P->>C: resume con a y b
Note over C: a y b llegan como parametros de la funcion
C->>P: yield con x
Note over P: x aparece detras del true de resume
P->>C: resume con y
Note over C: y aparece como resultado del yield anterior
C->>P: return con z
Note over P: z aparece detras del true y la corrutina muere

El primer resume y el último

El primer resume arranca la función, y por tanto sus argumentos van donde van los argumentos de cualquier llamada: a los parámetros declarados. Los siguientes no arrancan nada, porque la función ya está a medias, y por eso sus argumentos tienen que ir a otro sitio: al punto exacto donde la corrutina se detuvo.

local acumulador = coroutine.create(function(inicial)
  local total = inicial
  while true do
    local n = coroutine.yield(total)   -- cede total, recibe n
    total = total + n
  end
end)

print(coroutine.resume(acumulador, 10))  --> true  10
print(coroutine.resume(acumulador, 5))   --> true  15
print(coroutine.resume(acumulador, 3))   --> true  18

Observa el primer 10. Entró como argumento del primer resume, se ligó al parámetro inicial y volvió a salir en el mismo instante como argumento del primer yield. El 5 de la segunda línea, en cambio, no tocó ningún parámetro: apareció dentro de la corrutina como valor de la expresión coroutine.yield(total), que llevaba suspendida desde la línea anterior.

El otro extremo tiene su propia peculiaridad. Cuando la función retorna, sus valores salen por el mismo canal que los de una cesión, así que desde fuera un retorno y una cesión son indistinguibles por su forma. Y hay una asimetría más, fácil de pasar por alto: el yield que suspende la corrutina por última vez, si nadie vuelve a reanudarla nunca, nunca llega a evaluar sus valores de retorno. Los argumentos que le habrías pasado en un resume que no ocurre simplemente no existen.

La doble dirección de yield

Aquí está el núcleo de la lección. En Lua, coroutine.yield es una llamada a función corriente, con argumentos y con valores de retorno, y lo raro es que sus argumentos se evalúan en un instante y sus valores de retorno llegan en otro completamente distinto.

local peticion = coroutine.yield("necesito", "dos", "cosas")

Esa línea hace dos trabajos separados por una suspensión. Primero empaqueta las tres cadenas y suspende la corrutina; esos tres valores aparecen tras el true del resume que estaba esperando. Después, cuando alguien reanude —dentro de un microsegundo o dentro de media hora—, los argumentos de ese nuevo resume se convierten en los valores de retorno de esta misma llamada, y peticion recibe el primero de ellos.

La confusión clásica tiene dos formas y conviene reconocerlas escritas.

-- Forma 1: creer que yield devuelve lo que cedió
local x = coroutine.yield(42)
-- x NO vale 42. x vale lo que traiga el proximo resume.

-- Forma 2: creer que los argumentos del resume llegan a los parametros
local co = coroutine.create(function(a)
  coroutine.yield()
  print(a)              -- imprime el argumento del PRIMER resume, no del segundo
end)
coroutine.resume(co, "uno")
coroutine.resume(co, "dos")   --> imprime  uno

La cura es leer yield como lo que es: un punto de intercambio. A su izquierda están los valores que recibes de fuera, a su derecha, entre paréntesis, los que entregas. Escribir la línea completa local respuesta = coroutine.yield(pregunta) y decirla en voz alta como entrego la pregunta y espero aquí hasta que me traigan la respuesta elimina el problema de raíz, porque nombra el hecho de que entre las dos mitades de la frase hay una espera.

El desfase y sus consecuencias

Cuenta las operaciones de una corrutina que cede dos veces y luego retorna: hacen falta tres llamadas a resume y hay dos llamadas a yield. Siempre hay exactamente una reanudación más que cesiones, porque la primera reanudación no responde a ninguna cesión —arranca la función— y la última no es respondida por ninguna cesión, sino por el retorno.

Ese desfase de uno tiene tres consecuencias prácticas que explican bastante código real.

La primera es que un bucle de consumo escrito de forma ingenua ejecuta una reanudación de más, la que recoge el retorno. Por eso el patrón correcto comprueba el resultado en cada vuelta y no supone que cada resume traerá un valor útil.

local function consumir(co, ...)
  local vivos = { coroutine.resume(co, ...) }
  while vivos[1] and coroutine.status(co) ~= "dead" do
    procesar(table.unpack(vivos, 2))
    vivos = { coroutine.resume(co) }
  end
  return table.unpack(vivos, 2)     -- lo que devolvio la funcion, si termino bien
end

La segunda es que el valor que entra en el primer resume no puede usarse como respuesta a nada, porque no hay ninguna cesión esperándolo. Si tu protocolo es de tipo pregunta y respuesta, la corrutina tiene que empezar cediendo una pregunta antes de poder recibir su primera respuesta, y eso significa que el primer resume sirve para poner en marcha el diálogo y nada más. Es el motivo por el que tantos productores empiezan con un yield sin argumentos o con un valor de saludo.

La tercera es puramente aritmética y sin embargo es la fuente del fallo más molesto de este nivel: si construyes una máquina que alterna trabajos y llevas la cuenta de los pasos, tu contador de reanudaciones y tu contador de cesiones nunca coincidirán. Igualarlos a la fuerza produce un resume de más que devuelve false con cannot resume dead coroutine, o un yield de más que deja la corrutina viva cuando la creías terminada.