Overview

The Interpreter Pattern defines a grammatical representation for a lenguage and provides an interpreter to process sentences within that language. Classified as a behavioral pattern, it functions similarly to a compiler: it parses input based on specific syntax rules and extracts meaning. Essentially, it acts as a syntax analysis tool that distinguishes between terminal and non-terminal symbols, allowing the system to process different inputs based on their semantic meaning.

Common Use Cases

This pattern is ideal for scenarios involving recurring problems that can be described by a simple language. Typical examples include:

• Parsing musical notation (e.g., converting sheet music symbols into sounds).
• Decoding specific coding systems like Morse code.

You should consider using the Interpreter pattern when:

• A specific, recurring problem can be expressed in a simple statement or language.
• A grammar needs to be interpreted with relatively straightforward rules.

UML Structure

• Abstract Expression (Node): Declares an abstract evaluate or interpret method. All concrete syntax nodes implement this interface.
• Terminal Expression (Leaf): Handles the interpretation of the "end" elements in the grammar. For example, in a calculation A + B, the variables A and B are terminals. There is usually one class per terminal in the grammar.
• Non-Terminal Expression (Composite): Handles the interpretation of operators or complex rules. In A + B, the + operator is a non-terminal. These classes usually hold references to other expressions (like left and right operands).
• Context: Stores the global state or values associated with the terminals (e.g., mapping variable name A to the value 100).

Real-World Examples in Source Code

1. Java Regular Expressions (java.util.regex.Pattern)

The Pattern class compiles a regular expression string into an executable form. While the internal implementation is complex, the external behavior follows the interpreter concept: taking a string grammar and creating a structure to interpret it.

public final class Pattern implements java.io.Serializable {
    // Compiles the given regular expression into a pattern.
    public static Pattern compile(String regex) {
        return new Pattern(regex, 0);
    }

    // Internal constructor handling the compilation logic
    private Pattern(String p, int f) {
        // ... logic to build the syntax tree for the regex ...
        if (p.length() > 0) {
            compile(); // Internal method to parse the grammar
        }
    }
}

2. Spring Expression Language (SpEL)

Spring's ExpressionParser allows parsing of expression strings like "#{systemProperties['user.home']}". It interprets the string based on the SpEL grammar.

public interface ExpressionParser {
    // Parses the expression string into an Expression object
    Expression parseExpression(String expressionString) throws ParseException;

    // Parses with additional context
    Expression parseExpression(String expressionString, ParserContext context) throws ParseException;
}

Advantages and Disadvantages

Advantages:

• Extensibility: Adding new grammar rules is straightforward; you simply introduce new non-terminal expression classes.
• Decoupling: It provides a way to interpret sentences without hard-coding the logic everywhere.
• Simplicity for Small Grammars: Easy to implement for languages with simple syntax.

Disadvantages:

• Class Explosion: For complex grammars, the number of classes required (one for each rule) can become unmanageable.
• Performance: Since interpretation often involves recursive calls, performance can degrade with deeply nested expressions, making debugging difficult.

Sample Implementation

Below is a example of a simple calculator interpreter using the patttern. We define a context and different types of expressions.

import java.util.Map;
import java.util.HashMap;

// 1. Context
class ExecutionContext {
    private Map<string integer=""> variables = new HashMap<>();

    public void assign(String var, int value) {
        variables.put(var, value);
    }

    public int lookup(String var) {
        return variables.getOrDefault(var, 0);
    }
}

// 2. Abstract Expression
interface MathExpression {
    int solve(ExecutionContext context);
}

// 3. Terminal Expression (Variable)
class Variable implements MathExpression {
    private String name;

    public Variable(String name) {
        this.name = name;
    }

    public int solve(ExecutionContext context) {
        return context.lookup(name);
    }
}

// 4. Non-Terminal Expression (Addition)
class Addition implements MathExpression {
    private MathExpression left;
    private MathExpression right;

    public Addition(MathExpression left, MathExpression right) {
        this.left = left;
        this.right = right;
    }

    public int solve(ExecutionContext context) {
        return left.solve(context) + right.solve(context);
    }
}

// Client Usage
public class InterpreterDemo {
    public static void main(String[] args) {
        ExecutionContext ctx = new ExecutionContext();
        ctx.assign("x", 10);
        ctx.assign("y", 20);

        // Represents: x + y
        MathExpression expr = new Addition(new Variable("x"), new Variable("y"));
        
        System.out.println("Result: " + expr.solve(ctx)); // Output: 30
    }
}</string>