🔄 Biblioteca: Corrotinas

-- Criar corrotina a partir de uma função
função tarefa()
    exiba("Início")
    corrotina.ceda()
    exiba("Meio")
    corrotina.ceda()
    exiba("Fim")
fim

local co = corrotina.crie(tarefa)

-- Retomar corrotina
local sucesso, resultado = corrotina.retome(co)
-- Exibe: "Início"

corrotina.retome(co)
-- Exibe: "Meio"

corrotina.retome(co)
-- Exibe: "Fim"

-- Verificar sucesso
se não sucesso então
    exiba("Erro: " .. resultado)
fim

função contador()
    para i = 1, 5 faça
        exiba("Contando: " .. i)
        corrotina.ceda(i)  -- Retorna valor ao ceder
    fim
fim

local co = corrotina.crie(contador)

enquanto verdadeiro faça
    local ok, valor = corrotina.retome(co)
    se não ok ou não valor então
        interrompa
    fim
    exiba("Recebido: " .. valor)
fim

local co = corrotina.crie(função()
    corrotina.ceda()
fim)

-- Verificar estado
local estado = corrotina.obtenha_estado(co)
exiba(estado)  -- "suspenso"

corrotina.retome(co)
exiba(corrotina.obtenha_estado(co))  -- "suspenso"

corrotina.retome(co)
exiba(corrotina.obtenha_estado(co))  -- "morto"

-- Estados possíveis:
-- "executando" - está executando agora
-- "suspenso" - pausada, pode ser retomada
-- "normal" - ativa mas não executando
-- "morto" - terminou execução

-- Obter corrotina em execução
local co_atual, eh_principal = corrotina.obtenha_executando()

se eh_principal então
    exiba("Executando na thread principal")
fim

se não eh_principal então
    exiba("Executando em corrotina")
fim

função pode_pausar()
    se corrotina.verifique_pode_ceder() então
        exiba("Posso pausar aqui")
        corrotina.ceda()
    fim

    se não corrotina.verifique_pode_ceder() então
        exiba("Não posso pausar (não estou em corrotina)")
    fim
fim

-- Na thread principal
pode_pausar()  -- "Não posso pausar"

-- Em corrotina
local co = corrotina.crie(pode_pausar)
corrotina.retome(co)  -- "Posso pausar aqui"

-- Criar função que automaticamente retoma
função gerador()
    para i = 1, 3 faça
        corrotina.ceda(i * 10)
    fim
fim

local proxima = corrotina.envolva(gerador)

-- Chamar como função normal
exiba(proxima())  -- 10
exiba(proxima())  -- 20
exiba(proxima())  -- 30

local co = corrotina.crie(função()
    local recurso = "aberto"
    corrotina.ceda()
    exiba("Limpando recurso")
fim)

corrotina.retome(co)

-- Fechar corrotina (executa limpeza)
local sucesso, erro = corrotina.feche(co)
se sucesso então
    exiba("Corrotina fechada")
fim

função produtor()
    para i = 1, 5 faça
        exiba("Produzindo item " .. i)
        corrotina.ceda(i)
    fim
fim

função consumidor(prod)
    enquanto verdadeiro faça
        local ok, item = corrotina.retome(prod)
        se não ok ou não item então
            interrompa
        fim
        exiba("Consumindo item " .. item)
    fim
fim

local prod = corrotina.crie(produtor)
consumidor(prod)

função fibonacci(n)
    retorne corrotina.envolva(função()
        local a, b = 0, 1
        para i = 1, n faça
            corrotina.ceda(a)
            a, b = b, a + b
        fim
    fim)
fim

-- Usar como iterador
local fib = fibonacci(10)
para i = 1, 10 faça
    exiba(fib())
fim
-- Saída: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

função maquina_estados()
    exiba("Estado: INICIALIZANDO")
    corrotina.ceda("inicializado")

    exiba("Estado: PROCESSANDO")
    corrotina.ceda("processando")

    exiba("Estado: FINALIZANDO")
    corrotina.ceda("finalizado")

    exiba("Estado: COMPLETO")
fim

local maquina = corrotina.crie(maquina_estados)

enquanto corrotina.obtenha_estado(maquina) ~= "morto" faça
    local ok, estado = corrotina.retome(maquina)
    se estado então
        exiba("→ Transição para: " .. estado)
    fim
fim