TypeScript Academy · Les

Concepten van parsercombinators

Combineer kleine parsers tot grotere parsers

Les 1 van 413 stappen

Concepten van parsercombinators is een gratis TypeScript Academy-les op CoddyKit. Dit is les 1 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.

Wat is een parser

Een parser leest invoer (meestal een tekenreeks) en produceert gestructureerde uitvoer of mislukt. We beginnen op waardenniveau om intuïtie op te bouwen voordat we dezelfde ideeën naar het typesysteem verplaatsen.

type Parser<T> = (input: string) => { value: T; rest: string } | null;
// Consumes part of the input, returns a value and the leftover

Een kleine parser

De eenvoudigste parser herkent een letterlijk voorvoegsel. Als de invoer met de verwachte tekst begint, slaagt de parser en retourneert deze de resterende tekenreeks; anders retourneert deze null.

function literal(prefix: string): Parser<string> {
  return input =>
    input.startsWith(prefix)
      ? { value: prefix, rest: input.slice(prefix.length) }
      : null;
}
console.log(literal("ab")("abc"));

Combinatoren

Een combinator neemt kleine parsers en bouwt grotere. Deze compositiestijl is de reden dat deze aanpak parsercombinatoren heet: je stelt complexe parsers samen uit eenvoudige, herbruikbare onderdelen.

// Small parsers: digit, letter, literal
// Combinators: sequence, choice, many
// Compose them into: number, identifier, expression

Sequenties

Een sequentiecombinator voert eerst één parser uit en daarna een andere op de overgebleven invoer, waarbij de resultaten worden gekoppeld. Beide moeten slagen voordat de sequentie slaagt.

function seq<A, B>(pa: Parser<A>, pb: Parser<B>): Parser<[A, B]> {
  return input => {
    const ra = pa(input);
    if (!ra) return null;
    const rb = pb(ra.rest);
    if (!rb) return null;
    return { value: [ra.value, rb.value], rest: rb.rest };
  };
}

Sequentie gebruiken

Combineer twee letterlijke waarden om ze in volgorde te parsen. Het resultaat bevat beide gevonden delen en de resterende invoer.

const ab = seq(literal("a"), literal("b"));
const r = ab("abc");
console.log(r); // { value: ["a","b"], rest: "c" }

Keuze

Een keuzecombinator probeert de eerste parser; als die faalt, probeert hij de tweede. Hiermee druk je alternatieven uit, zoals "een cijfer of een letter".

function alt<T>(p1: Parser<T>, p2: Parser<T>): Parser<T> {
  return input => p1(input) ?? p2(input);
}

Herhaling

Een many-combinator past een parser herhaaldelijk toe totdat die faalt en verzamelt alle resultaten. Hiermee parse je lijsten, reeksen cijfers of witruimte.

function many<T>(p: Parser<T>): Parser<T[]> {
  return input => {
    const out: T[] = [];
    let rest = input;
    let r = p(rest);
    while (r) { out.push(r.value); rest = r.rest; r = p(rest); }
    return { value: out, rest };
  };
}

Resultaten transformeren

Een map-combinator transformeert het resultaat van een parser zonder te veranderen wat die verbruikt, bijvoorbeeld door gevonden cijfertekens om te zetten in een getal.

function map<A, B>(p: Parser<A>, f: (a: A) => B): Parser<B> {
  return input => {
    const r = p(input);
    return r ? { value: f(r.value), rest: r.rest } : null;
  };
}

Opbouwen

Met deze paar combinatoren (literal, seq, alt, many, map) kun je echte grammatica's parsen: getallen, identificatiegegevens en zelfs kleine expressietalen. Elke laag combineert de laag eronder.

const digit = alt(literal("0"), literal("1")); // toy digit
const digits = many(digit);
console.log(digits("0110x"));

Van waarden naar typen

Het cruciale inzicht: dezelfde compositiestructuur werkt ook op typeniveau. Daar is de "invoer" een letterlijke tekenreekstype en zijn parsers conditionele typen die template-literalinferentie gebruiken. Daar gaan we nu naartoe.

// Value level: (input: string) => { value, rest } | null
// Type level:  conditional types over string literal types

Waarom parsen op typeniveau

Met parsers op typeniveau kan de compiler de structuur van letterlijke tekenreeksen begrijpen: routepaden, opmaakstrings en querysleutels. De combinatorintuïtie die je hier hebt opgebouwd, sluit rechtstreeks aan op de technieken op typeniveau in de rest van deze cursus.

// Goal: parse "users/:id" into { id: string } at compile time

Korte controle

Toets je begrip van parsercombinatoren.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt op waardenniveau intuïtie voor parsers opgebouwd.

Een parser verbruikt invoer en retourneert een waarde plus resterende invoer, of faalt.
Combinatoren (seq, alt, many, map) combineren kleine parsers tot grote parsers.
Dezelfde structuur werkt ook op typeniveau.

Volgende stap: tekenreeksen splitsen in het typesysteem.

Gratis beginnen

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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Concepten van parsercombinators” gratis?

Ja — de volledige tekst van “Concepten van parsercombinators” 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 “Concepten van parsercombinators”?

Combineer kleine parsers tot grotere parsers 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 1 van 4.

Hoe lang duurt de les “Concepten van parsercombinators”?

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

← Terug naar TypeScript Academy