Interpreter

Ad-hoc parsing turns into spaghetti

Evaluating "5 + 3 - 2" by hand-walking tokens with nested if-else works — until the grammar grows a third operator, then parentheses, then precedence…

function evaluate(expr) {
  const tokens = expr.split(' ');
  let result = Number(tokens[0]);
  for (let i = 1; i < tokens.length; i += 2) {
    if (tokens[i] === '+') result += Number(tokens[i+1]);
    else if (tokens[i] === '-') result -= Number(tokens[i+1]);
    // new operator? edit this function again…
  }
  return result;
}

Every grammar rule becomes a class

Terminal rules (numbers) and non-terminal rules (operators) all implement the same interpret() contract. An expression is just a tree of them.

class NumberExpr {
  constructor(n) { this.n = n; }
  interpret() { return this.n; }
}
class AddExpr {
  constructor(left, right) { this.left = left; this.right = right; }
  interpret() { return this.left.interpret() + this.right.interpret(); }
}
// SubtractExpr mirrors AddExpr, with a "-"

Build the tree, then interpret() it bottom-up

Pick an expression. It builds real NumberExpr / AddExpr / SubtractExpr objects, then interpret() resolves leaves first, then parents.

Result: —

A tree of self-evaluating rules

• Each grammar rule is one class implementing interpret() — the expression itself is a tree of these objects.
• Great fit for small DSLs: config rules, query filters, feature-flag expressions.
• Caution: it does not scale to complex grammars — reach for a real parser / AST tool once rules multiply.