TypeScript Academy · Lección

Conceptos de combinadores de analizadores

Componga analizadores pequeños para crear otros mayores.

Conceptos de combinadores de analizadores es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

Qué es un parser

Un parser lee una entrada (normalmente una cadena) y produce una salida estructurada o falla. Comenzamos en el nivel de valores para desarrollar la intuición antes de trasladar las mismas ideas al sistema de tipos.

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

Un parser pequeño

El parser más sencillo busca un prefijo literal. Si la entrada comienza con el texto esperado, tiene éxito y devuelve la cadena restante; de lo contrario, devuelve 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

Un combinador recibe parsers pequeños y construye otros más grandes. Este estilo compositivo explica por qué el enfoque se denomina parser combinators: se ensamblan parsers complejos a partir de componentes sencillos y reutilizables.

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

Secuenciación

Un combinador de secuencia ejecuta un parser y, después, otro sobre lo que queda, agrupando sus resultados. Ambos deben tener éxito para que la secuencia tenga éxito.

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 de secuencias

Combine dos literales para analizarlos en orden. El resultado contiene ambas partes coincidentes y la entrada restante.

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

Alternativas

Un combinador de alternativas intenta el primer parser; si falla, intenta el segundo. Esto expresa alternativas, como «un dígito o una letra».

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

Repetición

Un combinador many aplica un parser repetidamente hasta que falla y recopila todos los resultados. Esto permite analizar listas, secuencias de dígitos o espacios en blanco.

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

Transformación de resultados

Un combinador map transforma el resultado de un parser sin cambiar lo que consume; por ejemplo, convierte caracteres de dígitos coincidentes en un 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;
  };
}

Construcción progresiva

A partir de estos pocos combinadores (literal, seq, alt, many, map) puede analizar gramáticas reales: números, identificadores e incluso pequeños lenguajes de expresiones. Cada capa compone la que está debajo.

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

De valores a tipos

La idea fundamental es que la misma estructura composicional funciona a nivel de tipos. Allí, la «entrada» es un tipo literal de cadena y los parsers son tipos condicionales que usan inferencia de literales de plantilla. A continuación pasaremos a ese nivel.

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

Por qué analizar a nivel de tipos

Los parsers a nivel de tipos permiten que el compilador comprenda la estructura de los literales de cadena: rutas, cadenas de formato y claves de consulta. La intuición sobre combinadores que ha desarrollado aquí se aplica directamente a las técnicas de nivel de tipos del resto del curso.

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

Comprobación rápida

Compruebe cuánto entiende los combinadores de parsers.

Resumen

Ha desarrollado una intuición sobre los parsers a nivel de valores.

Un parser consume una entrada y devuelve un valor junto con lo que sobra, o falla.
Los combinadores (seq, alt, many, map) componen parsers pequeños para formar otros más grandes.
La misma estructura se aplica a nivel de tipos.

A continuación: dividir cadenas en el sistema de tipos.

Preguntas frecuentes

¿La lección «Conceptos de combinadores de analizadores» es gratis?

Sí — el texto completo de «Conceptos de combinadores de analizadores» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conceptos de combinadores de analizadores»?

Componga analizadores pequeños para crear otros mayores. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Conceptos de combinadores de analizadores»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Conceptos de combinadores de analizadores
División de cadenas a nivel de tipos
Análisis con literales de plantilla
Un mini analizador de rutas a nivel de tipos

← Volver a TypeScript Academy