Partiële toepassing
Vul functieargumenten vooraf in.
Partiële toepassing is een gratis Lua Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.
Wat is gedeeltelijk toepassen?
Gedeeltelijk toepassen betekent dat je nu enkele argumenten van een functie vastlegt en de rest later meegeeft. Je krijgt een nieuwe functie terug die minder argumenten nodig heeft.
Zo kun je een algemene functie veranderen in een gespecialiseerde functie door de waarden die je al kent vast te zetten.
Een handmatig voorbeeld
Stel dat je een functie add hebt. Je kunt addFive bouwen door een sluiting te schrijven die 5 vastlegt en op het tweede getal wacht.
De vastgelegde waarde leeft voort in de teruggegeven functie, dus elke aanroep heeft alleen het overgebleven argument nodig.
local function add(a, b)
return a + b
end
local function addFive(b)
return add(5, b)
end
print(addFive(10))
print(addFive(2))Het eerste argument vastleggen
We kunnen dat patroon veralgemenen. Een hulpmiddel bind1 accepteert een functie en een vast eerste argument en geeft een nieuwe functie terug die het tweede argument verwacht.
De sluiting legt zowel f als de vastgezette waarde vast en geeft vervolgens alles door wanneer de functie wordt aangeroepen.
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))Variabele argumenten gebruiken
Gebruik de variadische syntaxis ... van Lua om een willekeurig aantal eerste argumenten vast te leggen. Je legt de vaste argumenten vast en voegt de latere argumenten toe wanneer de functie wordt aangeroepen.
De functies table.pack en table.unpack helpen om lijsten met argumenten op te slaan en uit te spreiden.
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))Meerdere argumenten vastleggen
Omdat partial een variadisch aantal argumenten accepteert, kun je meerdere argumenten tegelijk vastleggen. De teruggegeven functie heeft dan alleen de overgebleven argumenten nodig.
Hier zijn twee van de drie argumenten vooraf ingevuld, waardoor een functie met één argument overblijft.
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))Een praktische toepassing
Partiële toepassing komt goed tot zijn recht bij algemene hulpfuncties. Leg de configuratie één keer vast en gebruik de gespecialiseerde functie daarna meerdere keren opnieuw.
Hieronder wordt een algemene greet een begroetingsfunctie voor een vaste taal, die alleen nog een naam nodig heeft.
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"))Partiële toepassing versus currying
Currying verandert een functie met meerdere argumenten in een keten van functies met één argument, waarbij elke functie de volgende teruggeeft. Bij partiële toepassing leg je alleen enkele argumenten vast en blijft de rest een normale aanroep.
De twee technieken hangen samen, maar zijn verschillend: currying werkt één argument per keer, terwijl je bij partiële toepassing enkele argumenten meteen vastlegt.
local function curryAdd(a)
return function(b)
return function(c)
return a + b + c
end
end
end
print(curryAdd(1)(2)(3))Een functie met twee argumenten curryen
Met een kleine hulpfunctie kun je automatisch elke functie met twee argumenten curryen. Deze geeft een functie van het eerste argument terug, die vervolgens een functie van het tweede argument teruggeeft.
Zo ontstaan herbruikbare bouwfuncties met één argument, die prettig lezen in pijplijnen.
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 maken het mogelijk
Elke partieel toegepaste en gecurryde functie steunt op closures. De vastgelegde argumenten zijn vastgehouden lokale waarden die de teruggegeven functie onthoudt.
Omdat elke teruggegeven functie zijn eigen vastgehouden waarden heeft, kun je veilig veel gespecialiseerde varianten maken.
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))Wanneer je het gebruikt
Gebruik partiële toepassing om herhaling te verminderen wanneer je steeds opnieuw een functie met dezelfde eerste argumenten aanroept.
Het helpt ook om een functie aan te passen aan een interface die minder argumenten verwacht, zoals een callback die maar één waarde doorgeeft.
Geconfigureerde callbacks
Partiële toepassing werkt goed samen met map en filter. Je kunt een configuratieargument vooraf invullen, zodat de callback alleen het lijstelement ontvangt.
Zo blijft je pijplijn overzichtelijk en kun je het gedrag toch aanpassen.
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, ", "))Korte controle
Haal het verschil tussen deze twee verwante ideeën weer voor de geest.
Samenvatting
Bij partiële toepassing leg je enkele argumenten vast en geef je een nieuwe functie terug die de rest verwacht. Closures leggen daarbij de vastgelegde waarden vast.
Een variadische helper met partial maakt dit algemener, terwijl currying functies met één argument aan elkaar rijgt. Beide verminderen herhaling en passen functies aan voor callbacks.
Leer Lua met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 40
- Lessen
- 159
Veelgestelde vragen
Is de les “Partiële toepassing” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Partiële toepassing”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.
Wat leer ik in “Partiële toepassing”?
Vul functieargumenten vooraf in. Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Lua Academy te beginnen?
Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Partiële toepassing”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Lua Academy?
Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Functies als waarden
- map, filter, reduce
- Partiële toepassing
- Functies samenstellen