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
- 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.
← → paso · R repetir · Espacio pausa
Aprenderás
- Reconocer cuándo una regla de negocio es, en realidad, una frase de un lenguaje pequeño. (visto)
- Representar cada regla de la gramática con una clase que implementa `evaluate()`. (visto)
- Evaluar el árbol con un contexto y seguir cómo bajan las preguntas y suben las respuestas. (visto)
- Guardar la regla como datos (JSON) y construir el árbol a partir de ellos. (visto)
- Saber cuándo usar un lenguaje o una librería que ya existe en lugar de escribir el tuyo. (visto)