coroutine

Uma corrotina é usada para executar várias tarefas ao mesmo tempo a partir do mesmo script.Tarefas como essas podem incluir a produção de valores a partir de entradas ou o trabalho em uma subrotina ao resolver um problema maior.Uma tarefa nem precisa ter um ponto final definido, mas precisa definir tempos específicos em que ela renda (pausa) para que outras coisas possam ser trabalhadas.

Usando Corrotinas

Uma nova corrotina pode ser criada fornecendo uma função para coroutine.create().Uma vez criada, uma corrotina não começa a funcionar até a primeira chamada para coroutine.resume() que passa os argumentos para a função.Essa chamada retorna quando a função parar ou chamar coroutine.yield() e, quando isso acontecer, coroutine.resume() retorna os valores retornados pela função, os valores enviados para coroutine.yield() ou uma mensagem de erro.Se ele cometer erro, o segundo valor de retorno é o erro arremessado.

local function task(...)
	-- Essa função pode fazer algum trabalho por um tempo e então renderizar algum valor
	coroutine.yield("first")  -- Para ser retornado por coroutine.resume()
	-- A função continua uma vez que for retomada novamente
	return "second"
end

local taskCoro = coroutine.create(task)
-- Resume a chamada pela primeira vez, que executa a função desde o início
local success, result = coroutine.resume(taskCoro, ...)
print(success, result)  --> verdadeiro, primeiro (tarefa chamada coroutine.yield())
-- Continue executando a função até que ela retorne ou pare
success, result = coroutine.resume(taskCoro)
print(success, result)  --> true, second (task halted because it returned "second")

Durante a vida da corrotina, você pode chamar coroutine.status() para inspecionar seu status:

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

<tbody>
  <tr>
    <td><b>suspenso</b></td>

    <td>A corrotina está esperando para ser retomada. Corrotinas começam neste estado e entram nele quando sua função chama <code>coroutine.yield()</code> .</td>
  </tr>

  <tr>
    <td><b>executando</b></td>

    <td>A coroutine está rodando agora.</td>
  </tr>

  <tr>
    <td><b>normal</b></td>

    <td>A corrotina está aguardando a produção de outra corrotina; em outras palavras, ela retomou outra corrotina.</td>
  </tr>

  <tr>
    <td><b>morta</b></td>

    <td>A função foi interrompida (retornou ou lançou um erro). A corrotina não pode ser usada além disso.</td>
  </tr>
</tbody>

Envolver Corrotinas

Ao trabalhar com corrotinas, você também pode desistir do uso do objeto coroutine e, em vez disso, usar uma função de wrapper.Uma função de wrapper como essa retomará uma corrotina específica quando for chamada e retornará apenas os valores concedidos.Você pode fazer isso usando coroutine.wrap() :

-- Crie uma corrotina e retorne uma função de wrapper que a resume
local f = coroutine.wrap(task)
-- Resuma a corrotina como se chamássemos coroutine.resume()
local result = f()
-- Se um erro ocorrer, ele será levantado aqui!
-- This differs from coroutine.resume() which acts similar to pcall()

O primeiro valor retornado de coroutine.resume() descreve se uma corrotina foi executada sem erros.No entanto, funções retornadas por coroutine.wrap() não farão isso: em vez disso, elas retornarão diretamente os valores retornados ou passados para coroutine.yield(), se houver.Se um erro ocorreu ao executar a função de corrotina, o erro é levantado na chamada da função retornada.

Exemplo de Padrão de Produtor

Imagine uma tarefa que produza repetições de uma palavra: cada vez que produz uma repetição, a próxima produzirá mais uma.Por exemplo, fornecer Hello produzirá Hello , HelloHello , HelloHelloHello , etc.Para fazer isso, você pode definir repeatThis() :

-- Essa função repete uma palavra sempre que sua corrotina é retomada
local function repeatThis(word)
	local repetition = ""
	while true do
		-- Faça uma repetição e então obtenha o resultado
		repetition = repetition .. word
		coroutine.yield(repetition)
	end
end

Para executar essa função como uma corrotina, você pode usar coroutine.create() seguido por várias chamadas para coroutine.resume() :

local repetitionCoro = coroutine.create(repeatThis)
print(coroutine.resume(repetitionCoro, "Hello"))  -- verdade, Olá
print(coroutine.resume(repetitionCoro))           -- verdade, HelloHello
print(coroutine.resume(repetitionCoro))           -- true, HelloHelloHello

Para essa função de produtor, você também pode usar coroutine.wrap() para obter uma função que produza valores:

local f = coroutine.wrap(repeatThis)
print(f("Hello"))  -- Olá
print(f())         -- Olá Olá
print(f())         -- HelloHelloHello