Interpreter Pattern

The Interpreter Pattern provides a way to evaluate language grammar or expressions. It is used to define a representation of grammar along with an interpreter that uses the representation to interpret sentences in the language.

🧩 What is the Interpreter Pattern?

The Interpreter Pattern is a behavioral design pattern that specifies how to evaluate sentences in a language. It defines a grammar for a simple language and uses an interpreter to process statements of that language.

🎯 Real-World Analogy

Think of a calculator parsing a mathematical expression like "2 + 3 - 1". Each number and operation has meaning, and the system understands how to compute it by interpreting each token based on grammar rules.

📊 UML Diagram

classDiagram
    class AbstractExpression {
      <<interface>>
      + interpret(context)
    }
    class TerminalExpression {
      + interpret(context)
    }
    class NonTerminalExpression {
      + interpret(context)
    }
    class Context {
      + input
      + output
    }

    AbstractExpression <|-- TerminalExpression
    AbstractExpression <|-- NonTerminalExpression
  

🏗️ Structure and Participants

• Context: Holds the information that is global to the interpreter. This typically includes the input string or data to be parsed and any output or state needed during interpretation.
• AbstractExpression: Defines the common interface (usually an interpret(context) method) for all concrete expression classes. Every grammar rule or symbol will implement this interface.
• TerminalExpression: Implements the interpretation for grammar elements that do not contain other expressions (i.e., leaf nodes in the grammar tree). For example, numbers or variables in a mathematical expression.
• NonTerminalExpression: Implements grammar rules that involve other expressions (i.e., composite nodes). These classes combine terminal and/or non-terminal expressions to represent more complex grammar constructs, such as addition or subtraction in an arithmetic language.

💡 Use Cases

• Simple language interpreters (arithmetic, boolean)
• Rule engines or DSLs (Domain-Specific Languages)
• Command parsing in chatbots or command-line interfaces
• Validation engines for expressions or conditions

👨‍💻 Example Code

// Abstract Expression
interface IExpression {
    int Interpret();
}

// Terminal
class Number : IExpression {
    private int _value;
    public Number(int value) => _value = value;
    public int Interpret() => _value;
}

// Non-Terminal
class Add : IExpression {
    private IExpression _left, _right;
    public Add(IExpression left, IExpression right) {
        _left = left;
        _right = right;
    }
    public int Interpret() => _left.Interpret() + _right.Interpret();
}

// Usage
var expression = new Add(new Number(5), new Number(3));
Console.WriteLine(expression.Interpret()); // Output: 8
      

from abc import ABC, abstractmethod

class Expression(ABC):
    @abstractmethod
    def interpret(self):
        pass

class Number(Expression):
    def __init__(self, value):
        self.value = value
    def interpret(self):
        return self.value

class Add(Expression):
    def __init__(self, left, right):
        self.left = left
        self.right = right
    def interpret(self):
        return self.left.interpret() + self.right.interpret()

# Usage
expr = Add(Number(5), Number(3))
print(expr.interpret())  # Output: 8
      

⚖️ Pros and Cons

📌 When to Use

• You have a simple grammar to interpret.
• You want to implement a small language, query, or expression evaluator.
• You want a highly extensible solution where new rules are frequently added.

🧠 Quiz Time

📝 Summary

The Interpreter Pattern is powerful when used in the right scenarios, such as custom language parsers and expression evaluation engines. However, for complex grammars, it’s often better to use tools like ANTLR or parser generators.