Lua Academy · Aula

Geradores baseados em corrotinas

Use coroutine.wrap para criar sequências de geradores sob demanda.

Geradores baseados em corrotinas é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

Motivação para geradores com corrotinas

Os fechamentos funcionam bem para geradores simples. Porém, se a lógica de geração exigir laços aninhados ou um fluxo de controle complexo, um gerador com corrotina será muito mais claro.

Noções básicas de coroutine.wrap

coroutine.wrap(fn) retorna uma função. Cada chamada retoma a corrotina; os valores produzidos por coroutine.yield tornam-se o valor de retorno.

local gen = coroutine.wrap(function()
  coroutine.yield(1)
  coroutine.yield(2)
  coroutine.yield(3)
end)
for v in gen do print(v) end

Gerador de sequência infinita

Uma corrotina pode produzir valores indefinidamente, sendo perfeita para sequências infinitas encerradas pelo chamador com break.

local function naturals()
  return coroutine.wrap(function()
    local n = 0
    while true do
      n = n + 1
      coroutine.yield(n)
    end
  end)
end
for v in naturals() do
  if v > 5 then break end
  print(v)
end

Gerador de percurso em árvore

O percurso recursivo em profundidade é simples com corrotinas: basta produzir valores a partir das chamadas recursivas, sem gerenciar uma pilha explícita.

local function walkTree(node)
  return coroutine.wrap(function()
    local function recurse(n)
      coroutine.yield(n.value)
      for _, child in ipairs(n.children or {}) do
        recurse(child)
      end
    end
    recurse(node)
  end)
end

Gerador de Fibonacci

A sequência de Fibonacci é natural como uma corrotina: mantenha duas variáveis de estado e produza cada termo.

local function fibs()
  return coroutine.wrap(function()
    local a, b = 0, 1
    while true do
      coroutine.yield(a)
      a, b = b, a + b
    end
  end)
end
local fib = fibs()
for i = 1, 8 do print(fib()) end

Passando valores ao gerador

O argumento da função retomada é o valor de retorno de yield, permitindo uma comunicação bidirecional.

local acc = coroutine.wrap(function()
  local total = 0
  while true do
    local n = coroutine.yield(total)
    total = total + (n or 0)
  end
end)
acc()  -- start
print(acc(10))  -- 10
print(acc(5))   -- 15

coroutine.wrap em comparação com coroutine.create

wrap é mais simples e lança uma exceção em caso de erro. create retorna um objeto de execução e permite tratar erros a partir dos valores de retorno de resume.

Fluxo de geradores

Encadeie geradores baseados em corrotinas para criar fluxos preguiçosos: o produtor produz dados brutos, o filtro produz itens correspondentes e o mapeamento produz itens transformados.

Propagação de erros

Se uma corrotina encapsulada lançar um erro, a função de encapsulamento também lançará um erro. Envolva a chamada do gerador em pcall para consumi-lo com segurança.

Eficiência de memória

Geradores com corrotinas são preguiçosos: calculam valores sob demanda. Isso evita a criação de tabelas intermediárias grandes, uma grande vantagem para conjuntos de dados extensos.

Tratamento do esgotamento

Quando a função da corrotina retorna (em vez de produzir um valor), a chamada seguinte à função encapsulada retorna nil, encerrando naturalmente um laço for genérico.

Pergunta sobre geradores com corrotinas

O que acontece quando a função da corrotina de um gerador baseado em coroutine.wrap retorna (em vez de produzir um valor)?

Recapitulação: geradores com corrotinas

coroutine.wrap transforma qualquer corrotina em uma função geradora reutilizável. Ele permite sequências infinitas preguiçosas, percursos recursivos e etapas de fluxo com um fluxo de controle claro.

Perguntas Frequentes

A aula “Geradores baseados em corrotinas” é grátis?

Sim — o texto completo de “Geradores baseados em corrotinas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Geradores baseados em corrotinas”?

Use coroutine.wrap para criar sequências de geradores sob demanda. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Geradores baseados em corrotinas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Protocolo do for genérico
Iteradores sem estado
Iteradores com estado usando fechamentos
Geradores baseados em corrotinas

← Voltar para Lua Academy