Applicazione parziale
Precompili gli argomenti delle funzioni.
Applicazione parziale è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.
Che cos'è l'applicazione parziale?
L'applicazione parziale consiste nel fissare ora alcuni argomenti di una funzione e fornire i restanti in un secondo momento. Si ottiene una nuova funzione che richiede meno argomenti.
In questo modo può trasformare una funzione generica in una specializzata, fissando i valori già conosciuti.
Un esempio manuale
Supponga di avere una funzione add. Può creare addFive scrivendo una closure che cattura 5 e attende il secondo numero.
Il valore catturato rimane nella funzione restituita, quindi a ogni chiamata serve soltanto l'argomento rimanente.
local function add(a, b)
return a + b
end
local function addFive(b)
return add(5, b)
end
print(addFive(10))
print(addFive(2))Associare il primo argomento
Possiamo generalizzare questo schema. Un helper bind1 riceve una funzione e un primo argomento fisso, quindi restituisce una nuova funzione che attende il secondo.
La closure cattura sia f sia il valore fissato, quindi inoltra tutto quando viene chiamata.
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))Utilizzare i vararg
Per fissare un numero qualsiasi di argomenti iniziali, utilizzi la sintassi vararg di Lua .... Catturi gli argomenti fissi, quindi aggiunga quelli successivi al momento della chiamata.
Le funzioni table.pack e table.unpack aiutano a memorizzare ed espandere le liste di argomenti.
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))Fissare più argomenti
Poiché partial accetta un numero variabile di argomenti, è possibile fissarne più di uno alla volta. La funzione restituita richiederà quindi solo quelli rimanenti.
Qui vengono precompilati due dei tre argomenti, lasciando una funzione a un solo argomento.
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 pratico
L'applicazione parziale è particolarmente utile con le funzioni di utilità generiche. Fissi una volta la configurazione, quindi riutilizzi molte volte la funzione specializzata.
Qui sotto, una funzione generica greet diventa una funzione di saluto con la lingua fissata, che richiede solo un nome.
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"))Applicazione parziale e currying
Il currying trasforma una funzione con più argomenti in una catena di funzioni a un solo argomento, ciascuna delle quali restituisce la successiva. L'applicazione parziale si limita a fissare alcuni argomenti e lascia gli altri in una normale chiamata.
Sono concetti correlati, ma distinti: il currying procede un argomento alla volta, mentre l'applicazione parziale ne fissa alcuni subito.
local function curryAdd(a)
return function(b)
return function(c)
return a + b + c
end
end
end
print(curryAdd(1)(2)(3))Applicare il currying a una funzione a due argomenti
Un piccolo helper può applicare automaticamente il currying a qualsiasi funzione a due argomenti. Restituisce una funzione del primo argomento, che a sua volta restituisce una funzione del secondo.
In questo modo si ottengono costruttori riutilizzabili a un solo argomento, facili da leggere nelle pipeline.
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))Il ruolo delle closure
Ogni funzione ottenuta tramite applicazione parziale o currying si basa sulle closure. Gli argomenti fissati sono variabili locali catturate che la funzione restituita ricorda.
Poiché ogni funzione restituita ha i propri valori catturati, è possibile creare in sicurezza molte varianti specializzate.
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))Quando utilizzarla
Utilizzi l'applicazione parziale per eliminare le ripetizioni quando chiama più volte una funzione con gli stessi argomenti iniziali.
È utile anche per adattare una funzione a un'interfaccia che prevede meno argomenti, ad esempio un callback che passa un solo valore.
Callback configurate
L'applicazione parziale si abbina bene a map e filter. Può precompilare un argomento di configurazione, in modo che il callback riceva solo l'elemento della lista.
Questo mantiene pulita la pipeline, consentendo comunque di regolare il comportamento.
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, ", "))Verifica rapida
Ricordi la differenza tra due concetti correlati.
Riepilogo
L'applicazione parziale fissa alcuni argomenti e restituisce una nuova funzione che si aspetta quelli rimanenti, grazie alle closure che catturano i valori fissati.
Un helper partial basato su un numero variabile di argomenti generalizza questo approccio, mentre il currying concatena funzioni a un solo argomento. Entrambi riducono le ripetizioni e adattano le funzioni ai callback.
Domande Frequenti
La lezione «Applicazione parziale» è gratuita?
Sì — il testo completo di «Applicazione parziale» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.
Cosa imparerò in «Applicazione parziale»?
Precompili gli argomenti delle funzioni. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Lua Academy?
Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Applicazione parziale»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Lua Academy?
Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Le funzioni come valori
- map, filter, reduce
- Applicazione parziale
- Comporre funzioni