TypeScript Academy · Aula

Conceitos de Combinadores de Analisadores

Componha pequenos analisadores em analisadores maiores.

Conceitos de Combinadores de Analisadores é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

O Que É um Analisador

Um analisador lê uma entrada (geralmente uma cadeia de caracteres) e produz uma saída estruturada ou falha. Começamos no nível dos valores para construir a intuição antes de levar as mesmas ideias para o sistema de tipos.

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

Um Analisador Mínimo

O analisador mais simples corresponde a um prefixo literal. Se a entrada começar com o texto esperado, ele terá sucesso e retornará a cadeia restante; caso contrário, retornará 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"));

Combinadores

Um combinador recebe analisadores pequenos e constrói analisadores maiores. Esse estilo composicional explica por que a abordagem é chamada de combinadores de analisadores: você monta analisadores complexos a partir de partes simples e reutilizáveis.

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

Sequenciamento

Um combinador de sequência executa um analisador e depois outro sobre o restante, agrupando os resultados. Ambos devem ter sucesso para que a sequência seja bem-sucedida.

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

Usando sequência

Combine dois literais para analisá-los em ordem. O resultado contém as duas partes correspondentes e a entrada restante.

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

Escolha

Um combinador de escolha tenta o primeiro analisador; se ele falhar, tenta o segundo. Isso expressa alternativas, como "um digit ou uma letra".

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

Repetição

Um combinador many aplica um analisador repetidamente até ele falhar, reunindo todos os resultados. Isso permite analisar listas, sequências de digits ou espaços em branco.

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

Mapeando resultados

Um combinador map transforma o resultado de um analisador sem alterar o que ele consome, por exemplo, convertendo caracteres de digit correspondentes em um número.

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

Construindo gradualmente

A partir destes poucos combinadores (literal, sequência, alternativa, repetição, mapeamento), você pode analisar gramáticas reais: números, identificadores e até pequenas linguagens de expressões. Cada camada compõe a camada abaixo dela.

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

De valores a tipos

A ideia crucial é que a mesma estrutura composicional funciona no nível de tipos. Ali, a "entrada" é um tipo literal de cadeia de caracteres, e os analisadores são tipos condicionais que usam inferência de literais de modelo. Vamos passar para lá agora.

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

Por que analisar no nível de tipos

Os analisadores no nível de tipos permitem que o compilador compreenda a estrutura de cadeias de caracteres literais: caminhos de rotas, cadeias de caracteres de formato e chaves de query. A intuição sobre combinadores que você desenvolveu aqui se aplica diretamente às técnicas no nível de tipos usadas no restante deste curso.

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

Verificação rápida

Teste sua compreensão sobre combinadores de analisadores.

Recapitulação

Você desenvolveu uma intuição sobre analisadores no nível de valores.

Um analisador consome a entrada e retorna um valor mais o restante, ou falha.
Combinadores (sequência, alternativa, repetição, mapeamento) compõem analisadores pequenos em analisadores maiores.
A mesma estrutura se aplica no nível de tipos.

A seguir: divisão de cadeias de caracteres no sistema de tipos.

Perguntas Frequentes

A aula “Conceitos de Combinadores de Analisadores” é grátis?

Sim — o texto completo de “Conceitos de Combinadores de Analisadores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “Conceitos de Combinadores de Analisadores”?

Componha pequenos analisadores em analisadores maiores. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Conceitos de Combinadores de Analisadores”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Conceitos de Combinadores de Analisadores
Divisão de Textos no Nível de Tipos
Analisando com Literais de Modelo
Um Mini Analisador de Rotas no Nível de Tipos

← Voltar para TypeScript Academy