Railway-oriented programming
Koppel mogelijk falende bewerkingen zonder try/catch
Railway-oriented programming is een gratis TypeScript Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject TypeScript Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus TypeScript Academy bevat in totaal 4 lessen.
De spoorwegmetafoor
Spoorweggerichte programmering stelt een berekening voor als twee parallelle sporen: een succes- en een foutspoor. Zodra je naar het foutspoor overschakelt, blijf je daar en sla je de rest over.
Result-functies koppelen
Elke stap neemt een waarde aan en geeft een Result terug. We willen de stappen zo verbinden dat de eerste fout de keten vroegtijdig stopt en tot het einde wordt meegenomen.
type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
const err = <E>(error: E): Result<never, E> => ({ ok: false, error });map: de succeswaarde transformeren
map past een gewone functie toe op de waarde wanneer het Result ok is en geeft fouten ongewijzigd door. De functie blijft op het succespad.
function map<T, U, E>(r: Result<T, E>, f: (t: T) => U): Result<U, E> {
return r.ok ? ok(f(r.value)) : r;
}
console.log(map(ok(2), n => n + 1)); // { ok: true, value: 3 }flatMap: foutgevoelige stappen koppelen
Wanneer de volgende stap zelf een Result teruggeeft, gebruik je flatMap (ook wel andThen genoemd). Zo voorkom je geneste Results en stopt de keten bij een fout.
function flatMap<T, U, E>(r: Result<T, E>, f: (t: T) => Result<U, E>): Result<U, E> {
return r.ok ? f(r.value) : r;
}Waarom flatMap en niet map
Als je map met een functie die een Result teruggeeft zou gebruiken, krijg je Result<Result<U,E>,E>. flatMap maakt dat één niveau vlakker, zodat er één Result overblijft.
Stoppen bij de eerste fout
Zodra een stap err teruggeeft, geeft elke latere flatMap die fout ongewijzigd door. De resterende stappen worden nooit uitgevoerd, precies zoals bij het overschakelen naar het foutspoor.
const start = err("boom") as Result<number, string>;
const out = flatMap(start, n => ok(n + 1));
console.log(out); // { ok: false, error: "boom" }Een pijplijn bouwen
Combineer validatiestappen die elk een Result teruggeven. De eerste fout wordt het resultaat van de pijplijn; als alles slaagt, stroomt de succeswaarde door tot het einde.
function parseNum(s: string): Result<number, string> {
const n = Number(s);
return Number.isNaN(n) ? err("not a number") : ok(n);
}
function positive(n: number): Result<number, string> {
return n > 0 ? ok(n) : err("must be positive");
}De pijplijn uitvoeren
Door flatMap te koppelen, geef je de waarde door aan elke foutgevoelige stap. Een fout op welke plek dan ook stopt de keten en maakt die fout zichtbaar.
const good = flatMap(parseNum("5"), positive);
console.log(good); // { ok: true, value: 5 }
const bad = flatMap(parseNum("-3"), positive);
console.log(bad); // { ok: false, error: "must be positive" }map en flatMap combineren
Gebruik flatMap voor stappen die kunnen mislukken en map voor zuivere transformaties. Samen houden ze het succespad lineair en de foutafhandeling automatisch.
const result = map(flatMap(parseNum("10"), positive), n => n * 2);
console.log(result); // { ok: true, value: 20 }Geen try/catch nodig
De hele pijplijn drukt succes en fouten uit als waarden. Er is geen try/catch nodig en het type van elke stap maakt het foutpad expliciet en onmogelijk om te negeren.
Waarom dit schaalbaar is
Spoorweggerichte code houdt complexe werkstromen leesbaar: elke stap is klein en zuiver, fouten worden automatisch doorgegeven en een extra stap maakt de bestaande foutafhandeling niet ingewikkelder.
Korte controle
Korte controle van deze les.
Samenvatting
Spoorweggerichte programmering koppelt stappen die Result teruggeven met map (succes transformeren) en flatMap/andThen (foutgevoelige stappen koppelen en geneste Results vlak maken). De eerste err stopt de rest van de keten en wordt tot het einde doorgegeven, zonder try/catch.
Leer TypeScript 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
- 101
- Lessen
- 352
Veelgestelde vragen
Is de les “Railway-oriented programming” gratis?
Ja — de volledige tekst van “Railway-oriented programming” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus TypeScript Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus TypeScript Academy bevat in totaal 4 lessen.
Wat leer ik in “Railway-oriented programming”?
Koppel mogelijk falende bewerkingen zonder try/catch Je oefent met TypeScript 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 TypeScript Academy te beginnen?
Ervaring vooraf is niet nodig. TypeScript 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 “Railway-oriented programming”?
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 TypeScript Academy?
Ja. Elke les over TypeScript 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
- Het probleem met errors gooien
- Result-typen modelleren
- Option- en Maybe-typen
- Railway-oriented programming