Swift Academy · Les

Functiecompositie en pipelines

Datapipelines bouwen door kleine functies tot grotere transformaties te combineren.

Les 3 van 412 stappen

Functiecompositie en pipelines is een gratis Swift 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 Swift Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Swift Academy bevat in totaal 4 lessen.

Welkom

Functiecompositie combineert kleine, doelgerichte functies tot grotere bewerkingen. Het is de kern van functioneel programmeren — bouw complex gedrag op uit eenvoudige onderdelen.

Handmatige functiecompositie

```swift func double(_ n: Int) -> Int { n * 2 } func addOne(_ n: Int) -> Int { n + 1 } let result = addOne(double(5)) // 11 ```

Samenstellen met een hulpfunctie

```swift func compose(_ f: @escaping (B)->C, _ g: @escaping (A)->B) -> (A)->C { { f(g($0)) } } let doubleAndAdd = compose(addOne, double) print(doubleAndAdd(5)) // 11 ```

Aangepaste `>>>`-operator

```swift infixop precedencegroup CompositionPrecedence { ... } func >>> (f: @escaping (A)->B, g: @escaping (B)->C) -> (A)->C { { g(f($0)) } } let pipeline = double >>> addOne >>> String.init print(pipeline(5)) // "11" ```

Pijplijn met een map/filter-keten

```swift let process: ([Int]) -> [String] = { nums in nums.filter { $0 > 3 }.map { String($0 * 2) } } print(process([1,2,3,4,5])) // ["8","10"] ```

Stijl zonder expliciete argumenten

Bij een stijl zonder expliciete argumenten geef je tussenliggende argumenten geen naam: ```swift let words = ["hello","WORLD","Swift"] let lower = words.map { $0.lowercased() } // named let lower2 = words.map(\.description) // point-free where applicable ```

Sleutelpaden als functies

Swift-sleutelpaden kunnen als functies worden gebruikt: ```swift struct User { var name: String } let users = [User(name:"Alice"),User(name:"Bob")] let names = users.map(\.name) // ["Alice","Bob"] ```

Een gegevenspijplijn bouwen

```swift let pipeline: (String) -> Int? = { s in let trimmed = s.trimmingCharacters(in:.whitespaces) guard !trimmed.isEmpty else { return nil } return Int(trimmed) } [" 42 "," ","7"].compactMap(pipeline) // [42,7] ```

Partiële toepassing

```swift func add(_ a: Int) -> (Int) -> Int { { a + $0 } } let add5 = add(5) print([1,2,3].map(add5)) // [6,7,8] ```

Waarom compositie belangrijk is

Voordelen: • Elke functie is klein en testbaar • Pijplijnen zijn van boven naar beneden leesbaar • Hergebruik: `double` werkt op zichzelf of in elke pijplijn • Lui: combineer met `.lazy` om tussenliggende geheugenallocaties te vermijden

Korte controle

Welke functie van Swift maakt het mogelijk om sleutelpaden rechtstreeks als transformatiefuncties in `map` te gebruiken?

Beantwoord dit in de interactieve les

Samenvatting

Belangrijkste punten: • Stel kleine functies samen tot grotere transformaties • `>>>` of handmatige compositie voor herbruikbare pijplijnen • Sleutelpaden als functies voor het overzichtelijk ophalen van eigenschappen • Met partiële toepassing maak je gespecialiseerde functies • Combineer met `.lazy` voor pijplijnen zonder kopieën Volgende: luie reeksen.

Gratis beginnen

Leer Swift 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: 122
Lessen: 409

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Functiecompositie en pipelines” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Swift Academy, waaronder “Functiecompositie en pipelines”, 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 Swift Academy bevat in totaal 4 lessen.

Wat leer ik in “Functiecompositie en pipelines”?

Datapipelines bouwen door kleine functies tot grotere transformaties te combineren. Je oefent met Swift 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 Swift Academy te beginnen?

Ervaring vooraf is niet nodig. Swift 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 “Functiecompositie en pipelines”?

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 Swift Academy?

Ja. Elke les over Swift 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

Pure functies en een ontwerp zonder side-effects
Higher-order functies: map, flatMap, compactMap
Functiecompositie en pipelines
Lazy-sequenties voor efficiëntie

← Terug naar Swift Academy