Functies samenstellen
Koppel transformaties aan elkaar.
Functies samenstellen is een gratis Lua Academy-les op CoddyKit. Dit is les 4 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 compositie?
Functiecompositie combineert twee functies tot één functie. De samengestelde functie voert de invoer door de eerste functie en geeft het resultaat daarna door aan de tweede.
In de wiskunde schrijf je dit als f(g(x)). Met compositie kun je grote transformaties opbouwen uit kleine, doelgerichte functies.
Twee functies combineren
Een helper compose neemt twee functies en geeft een nieuwe functie terug. Als je die aanroept, wordt eerst g uitgevoerd en daarna wordt het resultaat doorgegeven aan f.
De volgorde is belangrijk: de binnenste functie wordt eerst uitgevoerd en de buitenste functie werkt op de uitvoer daarvan.
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))De volgorde is belangrijk
Als je de argumenten omwisselt, verandert het resultaat. compose(f, g) betekent dat je eerst g toepast en daarna f.
Het onderstaande voorbeeld laat zien dat eerst verdubbelen en daarna verhogen een ander antwoord geeft dan eerst verhogen en daarna verdubbelen.
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))Functies voor tekenreeksen combineren
Compositie werkt met alle functies met één argument, ook met bewerkingen op tekenreeksen. Combineer het verwijderen van witruimte, het wijzigen van hoofdletters en kleine letters of het omkeren tot één herbruikbare stap.
Hier wordt reverse eerst uitgevoerd en daarna upper, waardoor een tekenreeks in hoofdletters en omgekeerde volgorde ontstaat.
local function compose(f, g) return function(x) return f(g(x)) end end
local shout = compose(string.upper, string.reverse)
print(shout("lua"))Veel functies combineren
Als je meer dan twee functies wilt koppelen, schrijf je een variadische composeAll. Deze past de functies van rechts naar links toe, net als geneste aanroepen.
De lus doorloopt de functielijst achterwaarts en geeft de waarde door aan elke functie.
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))Van rechts naar links
In composeAll(a, b, c) wordt de meest rechtse functie c eerst uitgevoerd, daarna b en vervolgens a. Dit komt overeen met de geneste vorm a(b(c(x))).
Het kan lastig zijn om deze volgorde te lezen. Daarom geven sommige mensen de voorkeur aan een pijp van links naar rechts.
Een pijp van links naar rechts
Een pipe keert de leesvolgorde om: de functies worden van links naar rechts uitgevoerd, in de volgorde waarin ze zijn geschreven. Veel mensen vinden dit gemakkelijker te volgen voor gegevenspijplijnen.
De lus loopt vooruit en past elke functie toe op de huidige waarde.
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))Pijpen voor leesbaarheid
Met pipe lees je de stappen van boven naar beneden in de volgorde waarin ze worden uitgevoerd. Daardoor documenteren transformaties met meerdere stappen zichzelf.
Hier wordt een tekenreeks ontdaan van een voorvoegsel, omgezet naar kleine letters en vervolgens omgekeerd. Elke stap staat in de volgorde waarin die plaatsvindt.
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"))Compositie met closures
Je kunt functies combineren die met partiële toepassing of closures zijn gemaakt. Bouw kleine gespecialiseerde functies en verbind ze daarna met elkaar.
Zo blijft elk onderdeel testbaar, terwijl de compositie de algehele programmastroom uitdrukt.
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))Compositie en pijplijnen
Compositie is de verbindende schakel achter gegevenspijplijnen. In plaats van aanroepen diep te nesten, geef je een samengestelde functie één keer een naam en pas je die op veel invoerwaarden toe.
Dit werkt bijzonder goed met map: geef een samengestelde functie door als transformatie voor elk item.
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, ", "))Houd functies klein
Compositie beloont kleine functies met één doel. Elke functie doet één taak en samen vormen ze complex gedrag zonder dat je logica hoeft te herschrijven.
Dit is de kern van functioneel ontwerp: bouw een woordenschat van kleine functies en combineer ze vervolgens om grotere ideeën uit te drukken.
Korte controle
Volg de volgorde zorgvuldig voordat je antwoord geeft.
Samenvatting
Compositie combineert functies, zodat de uitvoer van de ene functie naar de volgende gaat. compose(f, g) voert g en daarna f uit, van rechts naar links, terwijl pipe van links naar rechts werkt voor betere leesbaarheid.
Met composeAll en pipe koppel je veel kleine functies tot duidelijke pijplijnen, vooral in combinatie met map.
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 “Functies samenstellen” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Functies samenstellen”, 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 “Functies samenstellen”?
Koppel transformaties aan elkaar. 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 4 van 4.
Hoe lang duurt de les “Functies samenstellen”?
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