Componer funciones
Encadene transformaciones
Componer funciones 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.
¿Qué es la composición?
La composición de funciones combina dos funciones en una sola. La función compuesta pasa su entrada por la primera función y luego entrega ese resultado a la segunda.
En matemáticas se escribe f(g(x)). La composición permite crear transformaciones grandes a partir de funciones pequeñas y específicas.
Componer dos funciones
Un auxiliar compose recibe dos funciones y devuelve una nueva. Al llamarlo, ejecuta primero g y luego pasa el resultado a f.
El orden es importante: la función interna se ejecuta primero y la función externa opera sobre su resultado.
local function compose(f, g)
return function(x)
return f(g(x))
end
end
local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end
local incThenDouble = compose(dbl, inc)
print(incThenDouble(3))El orden es importante
Intercambiar los argumentos cambia el resultado. compose(f, g) significa aplicar primero g y después f.
El ejemplo siguiente muestra que duplicar y luego incrementar produce un resultado diferente de incrementar y luego duplicar.
local function compose(f, g) return function(x) return f(g(x)) end end
local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end
print(compose(dbl, inc)(3))
print(compose(inc, dbl)(3))Componer funciones de cadenas
La composición funciona con cualquier función de un solo argumento, incluidas las transformaciones de cadenas. Puede encadenar el recorte, el cambio de mayúsculas y minúsculas o la inversión en un único paso reutilizable.
Aquí reverse se ejecuta primero y luego upper, lo que produce una cadena invertida en mayúsculas.
local function compose(f, g) return function(x) return f(g(x)) end end
local shout = compose(string.upper, string.reverse)
print(shout("lua"))Componer muchas funciones
Para encadenar más de dos funciones, escriba un composeAll variádico. Aplica las funciones de derecha a izquierda, como las llamadas anidadas.
El bucle recorre la lista de funciones hacia atrás y pasa el valor por cada una.
local function composeAll(...)
local fns = {...}
return function(x)
for i = #fns, 1, -1 do
x = fns[i](x)
end
return x
end
end
local f = composeAll(function(n) return n + 1 end,
function(n) return n * 2 end,
function(n) return n - 3 end)
print(f(10))De derecha a izquierda
En composeAll(a, b, c), la función situada más a la derecha, c, se ejecuta primero; después b y luego a. Esto coincide con la forma anidada a(b(c(x))).
Leer el orden puede resultar complicado, por lo que algunas personas prefieren un pipe de izquierda a derecha.
Un pipe de izquierda a derecha
Un pipe invierte el orden de lectura: las funciones se ejecutan de izquierda a derecha, en el orden en que están escritas. A muchas personas les resulta más fácil de seguir en los pipelines de datos.
El bucle avanza hacia delante y aplica cada función al valor acumulado.
local function pipe(...)
local fns = {...}
return function(x)
for i = 1, #fns do
x = fns[i](x)
end
return x
end
end
local process = pipe(function(n) return n + 1 end,
function(n) return n * 2 end)
print(process(5))Pipe para mejorar la legibilidad
Con pipe, los pasos se leen de arriba abajo, en el orden de ejecución. Esto hace que las transformaciones de varias etapas se expliquen por sí mismas.
Aquí se elimina de una cadena una idea de prefijo, se convierte a minúsculas y luego se invierte; cada paso aparece en el orden en que ocurre.
local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end
local transform = pipe(string.lower, string.reverse,
function(s) return "[" .. s .. "]" end)
print(transform("LUA"))Composición con cierres
Puede componer funciones creadas mediante aplicación parcial o cierres. Cree funciones pequeñas y especializadas y luego únalas.
Así cada pieza se puede probar por separado, mientras que la composición expresa el flujo general.
local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end
local function adder(n) return function(x) return x + n end end
local function muller(n) return function(x) return x * n end end
local calc = pipe(adder(3), muller(10))
print(calc(2))Composición y pipelines
La composición es el elemento que conecta los pipelines de datos. En lugar de anidar llamadas profundamente, asigne un nombre a una función compuesta una sola vez y aplíquela a muchas entradas.
Esto funciona especialmente bien con map: pase una función compuesta como transformación de cada elemento.
local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function compose(f, g) return function(x) return f(g(x)) end end
local step = compose(function(n) return n + 1 end, function(n) return n * n end)
local r = map({1, 2, 3, 4}, step)
print(table.concat(r, ", "))Mantenga las funciones pequeñas
La composición favorece las funciones pequeñas y con un único propósito. Cada una realiza una tarea y, al combinarlas, puede crear comportamientos complejos sin volver a escribir la lógica.
Este es el corazón del diseño funcional: cree un vocabulario de funciones diminutas y luego compóngalas para expresar ideas más grandes.
Comprobación rápida
Trace cuidadosamente el orden antes de responder.
Resumen
La composición combina funciones para que la salida de una pase a la siguiente. compose(f, g) ejecuta g y luego f, de derecha a izquierda, mientras que pipe se ejecuta de izquierda a derecha para mejorar la legibilidad.
Con composeAll y pipe puede encadenar muchas funciones pequeñas en pipelines claros, especialmente cuando los combina con map.
Preguntas frecuentes
¿La lección «Componer funciones» es gratis?
Sí — el texto completo de «Componer funciones» 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 «Componer funciones»?
Encadene transformaciones 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 «Componer funciones»?
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
- Las funciones como valores
- map, filter, reduce
- Aplicación parcial
- Componer funciones