Interpreter: un pequeño lenguaje propio

  • Lección 28 de 32
  • 11 min
  • Intermedio
  • 13 pasos

Una regla como «país MX y (edad ≥ 18 o plan pro)» copiada en tres archivos. Vas a convertirla en un árbol de objetos que se evalúa solo, y a ver cuándo conviene usar un lenguaje que ya existe.

Copias de la regla
—
Resultado
true
checkout.tscheckout.tsMX · 16 · prorules.jsonAndAnd · true&&PatternAnd · truecountry =MXcountry ·truefailure()country · trueOrOr · true== 'push'Or · trueage ≥ 18age ·falseage · falseplan = proplan ·trueplan · trueRuleinterfaceRuleEqEqAndAndOrOrla regla vive en el códigocheckout.tsconst promo =▸u.country === "MX" &&▸(u.age >= 18 || u.plan === "pro");if (promo) showPromo();checkout · banner · emailDónde vive la reglacheckout.tsage >= 18banner.tsage >= 18email.tsage >= 18cambiar a 21: 3 archivosraíz: AndOr dentro de AndLa frase como árbolAndcountry = "MX"Orage ≥ 18plan = "pro"hojas: Eq, Gtecompuestos: And, OrUn contrato, cuatro clasestype Ctx = Record<string, unknown>;interface Rule {▸evaluate(ctx: Ctx): boolean;}class Eq implements Rule { … }class Gte implements Rule { … }class And implements Rule { … }class Or implements Rule { … }c.country === "MX"c.age >= 18Una hojaclass Eq implements Rule {constructor(private key: string,private value: unknown) {}evaluate(c: Ctx) {▸return c[this.key] === this.value;}}pregunta a sus 2 hijoslo mismo, con ||Un compuestoclass And implements Rule {constructor(private a: Rule,private b: Rule) {}evaluate(c: Ctx) {▸return this.a.evaluate(c)▸&& this.b.evaluate(c);}}evaluate(user)16 < 18rule.evaluate(user)Andtruecountry = "MX"trueOrtrueage ≥ 18falseplan = "pro"trueuser = { MX, 16, pro }, valores de ejemplola regla como datosbuild(json) arma el árbolrules.json{ "and": [{ "eq": ["country", "MX"] },{ "or": [{ "gte": ["age", 18] },{ "eq": ["plan", "pro"] }]}] }texto → árbol: otro trabajosolo hace lo que definisteTres ideas equivocadas«es un lenguaje de programación»casi siempre, una regla«incluye el parser»parte del árbol«es como eval()»solo tus nodosGitHub evalúa la frase.github/workflows/ci.yml- name: Avisar al equipo▸if: ${{ failure() &&▸github.event_name == 'push' }}run: ./notify.shse compila una vezestado de cada búsquedaLenguajes que ya existen// Java: regex → Pattern▸Pattern p = Pattern.compile("a*b");Matcher m = p.matcher("aaaaab");boolean b = m.matches(); // true-- SQLite: SQL → bytecodeEXPLAIN SELECT * FROM users;una clase por reglaCuándo no usarloya hay un lenguajeregex, SQL, JSON Schemagramática grandeuna clase por reglabucle calienterecorrer el árbol cuestamuchas operacionesevalúa con Visitorun árbol, un evaluate()Interpreter en una tablaproblemauna regla copiada en el códigosoluciónuna clase por regla, un árbolhojascomparan un datocompuestospreguntan a sus hijosno lo usessi ya existe un lenguaje
  • petición
  • respuesta
  • evento

Paso 1 de 13

Problema

Una regla de negocio escrita a mano

Tu tienda muestra una promo a quien cumpla esto: vive en México y es mayor de edad o tiene el plan pro. En checkout.ts lo escribiste como una expresión con && y ||.

Funciona. Pero esa regla no es código de tu app: es una decisión de negocio que marketing va a querer cambiar, y está enterrada entre llamadas y variables.

Paso 2 de 13

Problema

La misma regla, en tres archivos

La promo también sale en el banner y en un email, así que la regla está copiada en banner.ts y email.ts. Tres copias en este ejemplo.

Marketing pide subir la edad mínima a 21. Toca abrir los tres archivos, cambiar el número y desplegar. Si olvidas uno, el banner promete una promo que el checkout no te deja usar.

Qué cambió

  • age >= 18 → age >= 21, tres veces

Paso 3 de 13

Concepto

La regla es una frase de un lenguaje pequeño

Mira la regla como una frase: country = "MX" And (age ≥ 18 Or plan = "pro"). Tiene palabras de un vocabulario chico: comparaciones, And y Or.

Toda frase así se puede dibujar como un árbol: And arriba, con dos hijos; uno de ellos es un Or, que tiene sus propios dos hijos. Las comparaciones son las hojas.

Paso 4 de 13

Concepto

Una clase por cada regla de la gramática

La idea de Interpreter: cada tipo de palabra del lenguaje es una clase, y todas cumplen el mismo contrato, Rule, con un único método: evaluate(ctx), que responde true o false.

Eq y Gte son hojas: comparan un dato. And y Or son compuestos: contienen otras reglas. Es el mismo árbol que viste en Composite, ahora con un trabajo concreto.

Qué cambió

  • interface Rule
  • Eq, Gte, And, Or

Paso 5 de 13

Técnica

Las hojas comparan un dato del contexto

Eq guarda una clave y un valor. Su evaluate busca esa clave en el contexto (los datos del usuario) y compara: c["country"] === "MX".

Gte es igual, pero con >=: Number(c[this.key]) >= this.min. Ninguna hoja sabe que existen And u Or; solo responden su pregunta.

Paso 6 de 13

Solución

And y Or le preguntan a sus hijos

And guarda dos Rule, sin saber de qué tipo son. Su evaluate le pide evaluate a cada hijo y combina con &&. Or hace lo mismo con ||.

Como un hijo puede ser otro And u Or, la frase puede anidarse tanto como quieras y nadie escribe un recorrido: la recursión sale sola.

Qué cambió

  • And.evaluate: a && b
  • Or.evaluate: a || b

Paso 7 de 13

Técnica

Un contexto entra, un true sale

Llamas rule.evaluate(user) con el usuario { country: "MX", age: 16, plan: "pro" }. And pregunta a country: true. Luego pregunta a Or, que pregunta a age: false, porque 16 < 18. Entonces Or pregunta a plan: true.

Or responde true, y And responde true: hay promo. Las preguntas bajan y las respuestas suben, igual que con && y ||: si country fuera false, And ni siquiera le preguntaría a Or.

Paso 8 de 13

Solución

La regla vive en un archivo, no en el código

Ahora la regla puede ser datos: un JSON con and, or, eq y gte. Una función build(json) lo recorre y crea el árbol de objetos, llamándose a sí misma en cada and y or.

Los tres archivos llaman rule.evaluate(user) sobre el mismo árbol: una sola copia. Subir la edad a 21 es cambiar un número en rules.json, y si la app lee ese archivo al arrancar o desde una configuración remota, ni siquiera hace falta desplegar.

Qué cambió

  • rules.json
  • build(json): Rule
  • tres copias de la regla

Paso 9 de 13

Concepto

Tres ideas equivocadas sobre Interpreter

«Es escribir un lenguaje de programación.» Casi nunca: lo normal es un filtro o una regla con cuatro o cinco tipos de nodo. «Incluye leer texto.» En esta lección partimos de un árbol o de JSON; convertir un texto como age >= 18 en árbol es otro trabajo, el de un parser.

«Es lo mismo que eval().» No: eval ejecuta cualquier código que le llegue. Tu árbol solo puede hacer lo que hacen Eq, Gte, And y Or. Por eso es más seguro aceptar reglas de fuera como datos que como código.

Paso 10 de 13

Técnica

El if de GitHub Actions es un lenguaje pequeño

En un workflow de GitHub Actions, if: acepta una expresión entre ${{ y }} con literales, comparaciones como ==, operadores && y ||, y funciones como failure() o contains().

Este paso avisa al equipo solo si algo falló y el evento fue un push. GitHub evalúa esa frase con el contexto del workflow, como tu rule.evaluate(user). Cada if: que escribes en tu CI es una frase de ese lenguaje.

Paso 11 de 13

Técnica

Regex y SQL: lenguajes que no tienes que escribir

Las expresiones regulares son el ejemplo clásico. En Java, Pattern.compile("a*b") convierte el texto en un Pattern; el estado de cada búsqueda vive en un Matcher, así que muchos Matcher pueden compartir un mismo Pattern.

SQLite va más lejos: compila cada sentencia SQL a un programa de bytecode que ejecuta su máquina virtual, y EXPLAIN te deja verlo. Los motores grandes no recorren un árbol de objetos en cada ejecución.

Paso 12 de 13

Compromiso

Cuándo tu propio lenguaje sobra

No lo uses si un lenguaje o una librería ya encaja, ni si la gramática es grande: con una clase por regla, las clases crecen rápido y te toca construir los mensajes de error y las herramientas tú solo. Recorrer el árbol en un bucle caliente también cuesta.

Y si al árbol le pides muchas cosas (evaluar, imprimir, validar), no las metas todas en los nodos. Robert Nystrom, en *Crafting Interpreters*, dice que el estilo del Gang of Four «se ensucia» si llenas de lógica las clases del árbol, y evalúa con un Visitor.

Paso 13 de 13

Resumen

Una regla, un árbol, un evaluate()

Cuando una regla de negocio se repite y cambia seguido, trátala como una frase: una clase por tipo de palabra, todas con evaluate(ctx), y un árbol que se arma desde datos.

Las hojas comparan y los compuestos preguntan a sus hijos. Si ya existe un lenguaje que encaja, como regex, SQL o las expresiones de tu CI, úsalo en lugar de escribir el tuyo.

Aprenderás

  • Reconocer cuándo una regla de negocio es, en realidad, una frase de un lenguaje pequeño.
  • Representar cada regla de la gramática con una clase que implementa `evaluate()`.
  • Evaluar el árbol con un contexto y seguir cómo bajan las preguntas y suben las respuestas.
  • Guardar la regla como datos (JSON) y construir el árbol a partir de ellos.
  • Saber cuándo usar un lenguaje o una librería que ya existe en lugar de escribir el tuyo.