coroutine

Se usa una coroutine para realizar múltiples tareas al mismo tiempo desde el mismo script.Tales tareas pueden incluir la producción de valores a partir de entradas o el trabajo en una subrutina al resolver un problema más grande.Una tarea ni siquiera necesita tener un punto final definido, pero sí necesita definir tiempos particulares en los que se produzca (pausa) para dejar que otras cosas se trabajen.

Usando corutinas

Se puede crear una nueva corutina al proporcionar una función a coroutine.create().Una vez creada, una coroutine no comienza a ejecutarse hasta la primera llamada a coroutine.resume() que pasa los argumentos a la función.Esta llamada se devuelve cuando la función se detiene o llama coroutine.yield() y, cuando esto sucede, coroutine.resume() devuelve los valores devueltos por la función, los valores enviados a coroutine.yield() o un mensaje de error.Si ocurre un error, el segundo valor de devolución es el error lanzado.

local function task(...)
	-- Esta función podría hacer un poco de trabajo por un tiempo y luego entregar algún valor
	coroutine.yield("first")  -- Para ser devuelto por coroutine.resume()
	-- La función continúa una vez que se reanuda nuevamente
	return "second"
end

local taskCoro = coroutine.create(task)
-- Llamar el resumen de la llamada por primera vez, que ejecuta la función desde el principio
local success, result = coroutine.resume(taskCoro, ...)
print(success, result)  --> verdadero, primero (la tarea llamada coroutine.yield())
-- Continúe ejecutando la función hasta que produzca o se detenga
success, result = coroutine.resume(taskCoro)
print(success, result)  --> true, second (task halted because it returned "second")

Durante la vida de la rutina, puedes llamar coroutine.status() para inspeccionar su estado:

<th>Significado</th>
  </tr>
</thead>

<tbody>
  <tr>
    <td><b>suspendido</b></td>

    <td>La corutina está esperando ser reanudada. Las corutinas comienzan en este estado y entran en él cuando su función llama <code>coroutine.yield()</code> .</td>
  </tr>

  <tr>
    <td><b>corriendo</b></td>

    <td>La corutina se está ejecutando ahora mismo.</td>
  </tr>

  <tr>
    <td><b>normales</b></td>

    <td>La corutina está esperando la entrega de otra corutina; en otras palabras, ha reanudado otra corutina.</td>
  </tr>

  <tr>
    <td><b>muerto</b></td>

    <td>La función se ha detenido (devuelto o lanzado un error). No se puede usar la coroutine más adelante.</td>
  </tr>
</tbody>

Embalaje de corutinas

Al trabajar con corutinas, también puedes renunciar al uso del objeto de corutina y usar una función de envoltura en su lugar.Tal función de envoltura reanudará una determinada coroutine cuando se llame y devolverá solo los valores entregados.Puedes hacer esto usando coroutine.wrap() :

-- Crear una rutina y devolver una función envolvente que la resume
local f = coroutine.wrap(task)
-- Resume la corutina como si llamáramos coroutine.resume()
local result = f()
-- Si ocurre un error, se levantará aquí!
-- This differs from coroutine.resume() which acts similar to pcall()

El primer valor devuelto de coroutine.resume() describe si una coroutine se ejecutó sin errores.Sin embargo, las funciones devueltas por coroutine.wrap() no harán esto: en cambio, devolverán directamente los valores devueltos o pasados a coroutine.yield() , si es que hay alguno.Si se ha producido un error mientras se ejecuta la función de corutina, el error se levanta en la llamada de la función devuelta.

Ejemplo de patrón productor

Imagina una tarea que produce repeticiones de una palabra: cada vez que produce una repetición, la siguiente producirá una más.Por ejemplo, proporcionar Hello producirá Hello , HelloHello , HelloHelloHello , etc.Para hacer esto, puedes definir repeatThis() :

-- Esta función repite una palabra cada vez que se reanuda su coroutine
local function repeatThis(word)
	local repetition = ""
	while true do
		-- Haz una repetición y luego obtén el resultado
		repetition = repetition .. word
		coroutine.yield(repetition)
	end
end

Para ejecutar esta función como una coroutine, puedes usar coroutine.create() seguido de múltiples llamadas a coroutine.resume() :

local repetitionCoro = coroutine.create(repeatThis)
print(coroutine.resume(repetitionCoro, "Hello"))  -- verdad, Hola
print(coroutine.resume(repetitionCoro))           -- verdad, HelloHello
print(coroutine.resume(repetitionCoro))           -- true, HelloHelloHello

Para esta función de productor, también puedes usar coroutine.wrap() para obtener una función que produzca valores:

local f = coroutine.wrap(repeatThis)
print(f("Hello"))  -- Hola
print(f())         -- HolaHola
print(f())         -- HelloHelloHello