TypeScript Academy · Lezione

Concetti dei parser combinator

Componga piccoli parser per crearne di più grandi.

Concetti dei parser combinator è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Che cos'è un parser

Un parser legge un input, solitamente una stringa, e produce un risultato strutturato oppure fallisce. Iniziamo dal livello dei valori per costruire l'intuizione, prima di trasferire le stesse idee nel sistema dei tipi.

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

Un parser essenziale

Il parser più semplice verifica un prefisso letterale. Se l'input inizia con il testo previsto, ha successo e restituisce la stringa rimanente; altrimenti restituisce 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"));

Combinatori

Un combinatore prende parser piccoli e ne costruisce di più grandi. Questo stile compositivo è il motivo per cui l'approccio si chiama combinatori di parser: si assemblano parser complessi a partire da componenti semplici e riutilizzabili.

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

Esecuzione in sequenza

Un combinatore di sequenza esegue un parser e poi un altro sul testo rimanente, associando i rispettivi risultati. Entrambi devono avere successo affinché la sequenza riesca.

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 };
  };
}

Uso della sequenza

Combini due literal per analizzarli nell'ordine. Il risultato contiene entrambe le parti corrispondenti e l'input rimanente.

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

Scelta

Un combinatore di scelta prova il primo parser; se fallisce, prova il secondo. In questo modo si esprimono alternative, come "una cifra o una lettera".

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

Ripetizione

Un combinatore many applica ripetutamente un parser finché non fallisce, raccogliendo tutti i risultati. Questo consente di analizzare liste, sequenze di cifre o spazi bianchi.

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 };
  };
}

Mappatura dei risultati

Un combinatore map trasforma il risultato di un parser senza modificare ciò che il parser consuma; per esempio, può trasformare i caratteri corrispondenti a cifre in un numero.

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;
  };
}

Costruzione progressiva

Partendo da questi pochi combinatori (literal, seq, alt, many, map) può analizzare grammatiche reali: numeri, identificatori e persino piccoli linguaggi di espressioni. Ogni livello compone quello sottostante.

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

Dai valori ai tipi

L'intuizione fondamentale è che la stessa struttura composizionale funziona anche a livello di tipo. In questo caso, l'"input" è un tipo literal di stringa e i parser sono conditional type che usano l'inferenza dei template literal. Ora passiamo a questo livello.

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

Perché analizzare a livello di tipo

I parser a livello di tipo permettono al compilatore di comprendere la struttura dei literal di stringa: percorsi di route, stringhe di formato e chiavi di query. L'intuizione sui combinatori acquisita qui si applica direttamente alle tecniche a livello di tipo del resto del corso.

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

Verifica rapida

Verifichi la Sua comprensione dei combinatori di parser.

Riepilogo

Ha sviluppato l'intuizione sui parser a livello di valore.

Un parser consuma l'input e restituisce un valore insieme all'input rimanente, oppure fallisce.
I combinatori (seq, alt, many, map) compongono piccoli parser per crearne di più grandi.
La stessa struttura si applica a livello di tipo.

Prossimo argomento: suddividere le stringhe nel sistema dei tipi.

Domande Frequenti

La lezione «Concetti dei parser combinator» è gratuita?

Sì — il testo completo di «Concetti dei parser combinator» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Concetti dei parser combinator»?

Componga piccoli parser per crearne di più grandi. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Concetti dei parser combinator»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?

Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Concetti dei parser combinator
Divisione di stringhe a livello di tipo
Parsing con i template literal
Un mini parser di route a livello di tipo

← Torna a TypeScript Academy