Aplicación parcial
Rellene previamente los argumentos de una función
Aplicación parcial es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 3 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 aplicación parcial?
La aplicación parcial consiste en fijar ahora algunos de los argumentos de una función y proporcionar el resto más adelante. Como resultado, se obtiene una función nueva que necesita menos argumentos.
Esto permite convertir una función general en una especializada al fijar los valores que ya conoce.
Un ejemplo manual
Suponga que tiene una función add. Puede crear addFive escribiendo una clausura que capture 5 y espere el segundo número.
El valor capturado permanece en la función devuelta, por lo que cada llamada solo necesita el argumento restante.
local function add(a, b)
return a + b
end
local function addFive(b)
return add(5, b)
end
print(addFive(10))
print(addFive(2))Vincular el primer argumento
Podemos generalizar ese patrón. Un auxiliar bind1 recibe una función y un primer argumento fijo, y devuelve una función nueva que espera el segundo.
La clausura captura tanto f como el valor fijado y, cuando se la llama, reenvía todos los valores.
local function bind1(f, a)
return function(b)
return f(a, b)
end
end
local function mul(x, y) return x * y end
local double = bind1(mul, 2)
print(double(7))
print(double(50))Usar argumentos variables
Para fijar cualquier cantidad de argumentos iniciales, utilice la sintaxis de argumentos variables de Lua .... Capture los argumentos fijos y añada los posteriores en el momento de la llamada.
Las funciones table.pack y table.unpack ayudan a almacenar y expandir las listas de argumentos.
local function partial(f, ...)
local fixed = table.pack(...)
return function(...)
local rest = table.pack(...)
local args = {}
for i = 1, fixed.n do args[i] = fixed[i] end
for i = 1, rest.n do args[fixed.n + i] = rest[i] end
return f(table.unpack(args, 1, fixed.n + rest.n))
end
end
local function add3(a, b, c) return a + b + c end
local add10 = partial(add3, 10)
print(add10(2, 3))Fijar varios argumentos
Como partial acepta un número variable de argumentos, puede fijar más de un argumento a la vez. La función devuelta solo necesitará los argumentos restantes.
Aquí se preestablecen dos de los tres argumentos, por lo que queda una función de un solo argumento.
local function partial(f, ...)
local fixed = table.pack(...)
return function(...)
local rest = table.pack(...)
local args = {}
for i = 1, fixed.n do args[i] = fixed[i] end
for i = 1, rest.n do args[fixed.n + i] = rest[i] end
return f(table.unpack(args, 1, fixed.n + rest.n))
end
end
local function label(prefix, sep, value) return prefix .. sep .. value end
local tag = partial(label, "id", ":")
print(tag(42))Un uso práctico
La aplicación parcial resulta especialmente útil con funciones de utilidad generales. Fije la configuración una vez y luego reutilice muchas veces la función especializada.
A continuación, una función genérica greet se convierte en una función de saludo con un idioma fijo que solo necesita un nombre.
local function greet(lang, name)
if lang == "tr" then return "Merhaba, " .. name end
return "Hello, " .. name
end
local function bind1(f, a) return function(b) return f(a, b) end end
local greetTr = bind1(greet, "tr")
print(greetTr("Ada"))
print(greetTr("Lin"))Aplicación parcial frente a currificación
La currificación convierte una función con varios argumentos en una cadena de funciones de un solo argumento, donde cada una devuelve la siguiente. La aplicación parcial simplemente fija algunos argumentos y mantiene los demás para una llamada normal.
Están relacionadas, pero son conceptos distintos: la currificación procesa los argumentos de uno en uno; la aplicación parcial fija algunos de inmediato.
local function curryAdd(a)
return function(b)
return function(c)
return a + b + c
end
end
end
print(curryAdd(1)(2)(3))Currificar una función de dos argumentos
Un pequeño auxiliar puede currificar automáticamente cualquier función de dos argumentos. Devuelve una función del primer argumento que, a su vez, devuelve una función del segundo.
Esto produce constructores reutilizables de un solo argumento que se leen muy bien en los pipelines.
local function curry2(f)
return function(a)
return function(b)
return f(a, b)
end
end
end
local function pow(base, exp) return base ^ exp end
local cpow = curry2(pow)
print(cpow(2)(10))Los cierres lo hacen posible
Tanto las funciones con aplicación parcial como las funciones currificadas dependen de los cierres. Los argumentos fijados son variables locales capturadas que la función devuelta recuerda.
Como cada función devuelta tiene sus propios valores capturados, puede crear muchas variantes especializadas de forma segura.
local function bind1(f, a) return function(b) return f(a, b) end end
local function sub(x, y) return x - y end
local from100 = bind1(sub, 100)
local from10 = bind1(sub, 10)
print(from100(40))
print(from10(3))Cuándo utilizarla
Utilice la aplicación parcial para evitar repeticiones cuando llame una y otra vez a una función con los mismos argumentos iniciales.
También ayuda a adaptar una función a una interfaz que espera menos argumentos, como un callback que solo pasa un valor.
Callbacks configurados
La aplicación parcial combina muy bien con map y filter. Puede preestablecer un argumento de configuración para que el callback solo reciba el elemento de la lista.
Así mantiene limpio el pipeline y, al mismo tiempo, puede ajustar el comportamiento.
local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function bind1(f, a) return function(b) return f(a, b) end end
local function scale(factor, x) return factor * x end
local r = map({1,2,3,4}, bind1(scale, 10))
print(table.concat(r, ", "))Comprobación rápida
Recuerde la diferencia entre dos conceptos relacionados.
Resumen
La aplicación parcial fija algunos argumentos y devuelve una nueva función que espera los restantes; para ello utiliza cierres que capturan los valores fijados.
Un auxiliar partial basado en un número variable de argumentos generaliza este mecanismo, mientras que la currificación encadena funciones de un solo argumento. Ambos enfoques reducen la repetición y adaptan funciones a callbacks.
Preguntas frecuentes
¿La lección «Aplicación parcial» es gratis?
Sí — el texto completo de «Aplicación parcial» 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 «Aplicación parcial»?
Rellene previamente los argumentos de una función 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 3 de 4.
¿Cuánto tiempo toma la lección «Aplicación parcial»?
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