Lua Academy · Lección

Generadores basados en coroutines

Utilice coroutine.wrap para crear secuencias de generadores perezosos.

Generadores basados en coroutines es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

Motivación de los generadores con coroutines

Las clausuras funcionan bien para generadores sencillos. Sin embargo, si la lógica de generación requiere bucles anidados o un flujo de control complejo, un generador basado en una coroutine resulta mucho más claro.

Conceptos básicos de coroutine.wrap

coroutine.wrap(fn) devuelve una función. Cada llamada reanuda la coroutine; los valores producidos mediante coroutine.yield se convierten en el 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

Generador de secuencias infinitas

Una coroutine puede producir valores indefinidamente, por lo que resulta perfecta para secuencias infinitas que el llamador termina con 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

Generador de recorridos de árboles

El recorrido recursivo en profundidad es sencillo con coroutines: basta con producir valores desde las llamadas recursivas sin administrar una pila 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

Generador de Fibonacci

La sucesión de Fibonacci se adapta naturalmente a una coroutine: mantenga dos variables de estado y produzca cada término.

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

Pasar valores al generador

El argumento de la función reanudada es el valor de retorno de yield, lo que permite la comunicación bidireccional.

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 frente a coroutine.create

wrap es más sencillo y genera un error. create devuelve un objeto de tipo thread y permite gestionar los errores a partir de los valores de retorno de resume.

Pipeline de generadores

Encadene generadores basados en coroutines para crear pipelines perezosos: el productor produce datos sin procesar, el filtro produce los elementos coincidentes y el mapeo produce los elementos transformados.

Propagación de errores

Si una coroutine envuelta genera un error, la función de envoltura también lo genera. Envuelva la llamada al generador en pcall para consumirlo de forma segura.

Eficiencia de memoria

Los generadores basados en coroutines son perezosos: calculan los valores bajo demanda. Esto evita crear tablas intermedias grandes, una ventaja importante para conjuntos de datos grandes.

Gestión del agotamiento

Cuando la función de la coroutine retorna (en lugar de producir un valor), la siguiente llamada a la función envuelta devuelve nil, lo que termina de forma natural un bucle genérico for.

Pregunta sobre generadores con coroutines

¿Qué sucede cuando la función de una coroutine basada en coroutine.wrap retorna (en lugar de producir un valor)?

Resumen: generadores con coroutines

coroutine.wrap convierte cualquier coroutine en una función generadora reutilizable. Permite crear secuencias infinitas perezosas, recorridos recursivos y etapas de pipeline con un flujo de control claro.

Preguntas frecuentes

¿La lección «Generadores basados en coroutines» es gratis?

Sí — el texto completo de «Generadores basados en coroutines» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Generadores basados en coroutines»?

Utilice coroutine.wrap para crear secuencias de generadores perezosos. Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Generadores basados en coroutines»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Lua Academy