Partiell applicering
Förifyll funktionsargument.
Partiell applicering är en gratis lektion i Lua Academy på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lua Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lua Academy innehåller totalt 4 lektioner.
Vad är partiell applicering
Partiell applicering innebär att vissa av en funktions argument låses nu och att resten anges senare. Resultatet blir en ny funktion som behöver färre argument.
På så sätt kan en generell funktion omvandlas till en specialiserad funktion genom att värden som redan är kända låses fast.
Ett manuellt exempel
Anta att det finns en funktion add. Funktionen addFive kan byggas genom att skriva en closure som fångar värdet 5 och väntar på det andra talet.
Det infångade värdet lever kvar i den returnerade funktionen, så varje anrop behöver bara det återstående argumentet.
local function add(a, b)
return a + b
end
local function addFive(b)
return add(5, b)
end
print(addFive(10))
print(addFive(2))Bind det första argumentet
Mönstret kan generaliseras. Hjälpfunktionen bind1 tar en funktion och ett fast första argument och returnerar en ny funktion som förväntar sig det andra.
Closuren fångar både f och det låsta värdet och skickar sedan vidare allt när den anropas.
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))Använd variabla argument
Om ett valfritt antal inledande argument ska låsas används Luas vararg-syntax .... De fasta argumenten fångas och de senare läggs till när funktionen anropas.
Funktionerna table.pack och table.unpack hjälper till att lagra och sprida argumentlistor.
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))Förinställa flera argument
Eftersom partial tar emot en vararg kan du förinställa flera argument på en gång. Den returnerade funktionen behöver då bara de återstående argumenten.
Här är två av tre argument förinställda, vilket lämnar en funktion med ett argument.
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))Praktisk användning
Partiell applicering är särskilt användbar för generella hjälpfunktioner. Förinställ konfigurationen en gång och återanvänd sedan den specialiserade funktionen många gånger.
Nedan blir en generell greet en hälsningsfunktion för ett fast språk som bara behöver ett namn.
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"))Partiell applicering jämfört med currying
Currying omvandlar en funktion med flera argument till en kedja av funktioner med ett argument, där varje funktion returnerar nästa. Partiell applicering förinställer bara vissa argument och behåller resten som ett vanligt funktionsanrop.
Begreppen hänger ihop men är olika: currying sker ett argument i taget, medan partiell applicering förinställer vissa argument direkt.
local function curryAdd(a)
return function(b)
return function(c)
return a + b + c
end
end
end
print(curryAdd(1)(2)(3))Currying av en funktion med två argument
En liten hjälpfunktion kan automatiskt tillämpa currying på vilken funktion som helst med två argument. Den returnerar en funktion för det första argumentet, som i sin tur returnerar en funktion för det andra.
Detta ger återanvändbara byggfunktioner med ett argument som blir lättlästa i 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))Closures får det att fungera
Alla partiellt applicerade och curriade funktioner bygger på closures. De förinställda argumenten är infångade lokala variabler som den returnerade funktionen kommer ihåg.
Eftersom varje returnerad funktion har sina egna infångade värden kan du på ett säkert sätt skapa många specialiserade varianter.
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))När det är användbart
Använd partiell applicering för att slippa upprepningar när du gång på gång anropar en funktion med samma inledande argument.
Det hjälper också till att anpassa en funktion till ett gränssnitt som förväntar sig färre argument, till exempel en callback som bara skickar ett värde.
Konfigurerade callback-funktioner
Partiell applicering passar bra ihop med map och filter. Du kan förinställa ett konfigurationsargument så att callback-funktionen bara tar emot listelementet.
Det håller pipelinen ren samtidigt som du fortfarande kan finjustera beteendet.
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, ", "))Snabb kontroll
Påminn dig om skillnaden mellan två närbesläktade idéer.
Sammanfattning
Partiell applicering förinställer vissa argument och returnerar en ny funktion som förväntar sig resten. Den bygger på closures som fångar de förinställda värdena.
En partial-hjälpfunktion baserad på vararg generaliserar detta, medan currying kedjar funktioner med ett argument. Båda minskar upprepningar och anpassar funktioner till callback-funktioner.
Lär dig Lua med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 40
- Lektioner
- 159
Vanliga frågor
Är lektionen ”Partiell applicering” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lua Academy, inklusive ”Partiell applicering”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lua Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Partiell applicering”?
Förifyll funktionsargument. Ni övar på Lua Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Lua Academy?
Du behöver inga förkunskaper. Utbildningen i Lua Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Partiell applicering”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Lua Academy-lektionen?
Ja. Varje Lua Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Funktioner som värden
- map, filter, reduce
- Partiell applicering
- Sätt samman funktioner