Interpreter Pattern | Behavioral design pattern

Interpreter Pattern

The Interpreter Pattern is a behavioral design pattern that defines a grammar for a language and provides an interpreter to interpret sentences in that language. It's often used for creating domain-specific languages or parsing expressions.

Where to Use:

1. Domain-Specific Languages (DSLs): When you need to create a language specific to your application domain, like query languages or configuration languages, the Interpreter Pattern can be valuable.

2. Parsing and Compilers: It's useful for parsing and interpreting expressions or statements, making it applicable in building simple parsers and compilers.

3. Rule-Based Systems: In systems where rules need to be expressed and interpreted, such as expert systems or validation engines, the Interpreter Pattern can be beneficial.

4. Text Processing: When dealing with textual patterns or structures, like regular expressions or template languages, interpreters can be implemented using this pattern.

Why to Use:

1. Flexibility: It allows you to define and extend grammars dynamically. You can add new expressions or modify existing ones without changing the client code.

2. Readability: It can enhance the readability of code when dealing with complex grammatical rules by representing them as hierarchical objects.

3. Ease of Maintenance: If the grammar changes or new language constructs are introduced, you can create new interpreter classes or modify existing ones without affecting other parts of the code.

When to Use:

1. When Grammar is Stable: Use the Interpreter Pattern when the grammar of the language to interpret is relatively stable, and variations can be handled by creating new expressions.

2. Expression Evaluation: When you need to evaluate expressions in a language, especially if the expressions can be represented as abstract syntax trees.

3. Scenarios with Rules or Policies: In applications where there are rules or policies that need to be interpreted, such as business rules or validation rules.

Remember, while the Interpreter Pattern can be powerful, it might be overkill for simpler scenarios where a more straightforward approach suffices. It's beneficial in situations where a language or set of rules needs to be interpreted and evaluated dynamically.

Key components of the Interpreter Pattern include:

1. AbstractExpression: Declares an abstract interface for interpreting expressions.

2. TerminalExpression: Implements the abstract interface for terminal symbols in the language.

3. NonTerminalExpression: Implements the abstract interface for non-terminal symbols, combining multiple expressions.

4. Context: Contains information that is global to the interpreter and may affect the interpretation.

5. Client: Builds the abstract syntax tree and initiates the interpretation.

The pattern works by representing the grammar as a hierarchical structure of classes, with each class corresponding to a language element. Instances of these classes form an abstract syntax tree, and the interpreter traverses this tree to interpret the input expressions.

Simple example of constructing and parsing a basic query language using the Interpreter Pattern in C#.

We'll create a query language for filtering items based on attributes.

// AbstractExpression

public interface IQueryExpression

{

    bool Interpret(Item item);

}

// TerminalExpressions

public class AttributeEqualsExpression : IQueryExpression

{

    private string _attribute;

    private string _value;

    public AttributeEqualsExpression(string attribute, string value)

    {

        _attribute = attribute;

        _value = value;

    }

    public bool Interpret(Item item)

    {

        return item.HasAttribute(_attribute) && item.GetAttributeValue(_attribute) == _value;

    }

}

// NonTerminalExpression

public class AndExpression : IQueryExpression

{

    private IQueryExpression _left;

    private IQueryExpression _right;

    public AndExpression(IQueryExpression left, IQueryExpression right)

    {

        _left = left;

        _right = right;

    }

    public bool Interpret(Item item)

    {

        return _left.Interpret(item) && _right.Interpret(item);

    }

}

// Context

public class Item

{

    private Dictionary<string, string> _attributes = new Dictionary<string, string>();

    public void AddAttribute(string attribute, string value)

    {

        _attributes[attribute] = value;

    }

    public bool HasAttribute(string attribute)

    {

        return _attributes.ContainsKey(attribute);

    }

    public string GetAttributeValue(string attribute)

    {

        return _attributes[attribute];

    }

}

// Client

class Program

{

    static void Main()

    {

        // Construct query: (Color equals 'Red' and Type equals 'Car')

        IQueryExpression query = new AndExpression(

            new AttributeEqualsExpression("Color", "Red"),

            new AttributeEqualsExpression("Type", "Car")

        );

        // Sample items

        Item car1 = new Item();

        car1.AddAttribute("Color", "Red");

        car1.AddAttribute("Type", "Car");

        Item car2 = new Item();

        car2.AddAttribute("Color", "Blue");

        car2.AddAttribute("Type", "Car");

        // Evaluate the query

        Console.WriteLine("Query result for car1: " + query.Interpret(car1)); // Output: True

        Console.WriteLine("Query result for car2: " + query.Interpret(car2)); // Output: False

    }

}

In this example, `AttributeEqualsExpression` represents a terminal expression for checking if a specific attribute equals a given value. The `AndExpression` is a non-terminal expression for combining multiple conditions with an AND operator. The client constructs a query expression and evaluates it against sample items.

This is a simplified example, and in a real-world scenario, you might have a more complex query language with additional features and operators.

Another very simple real-world example in C# using the Interpreter Pattern. Suppose we want to create an interpreter for basic arithmetic expressions.

// AbstractExpression

public interface IExpression

{

    int Interpret(Context context);

}

// TerminalExpression

public class NumberExpression : IExpression

{

    private int _number;

    public NumberExpression(int number)

    {

        _number = number;

    }

    public int Interpret(Context context)

    {

        return _number;

    }

}

// NonTerminalExpression

public class AdditionExpression : IExpression

{

    private IExpression _left;

    private IExpression _right;

    public AdditionExpression(IExpression left, IExpression right)

    {

        _left = left;

        _right = right;

    }

    public int Interpret(Context context)

    {

        return _left.Interpret(context) + _right.Interpret(context);

    }

}

// Context

public class Context

{

    // Additional context, if needed

}

// Client

class Program

{

    static void Main()

    {

        // Build expression tree: 1 + 2 + 3

        IExpression expression = new AdditionExpression(

            new NumberExpression(1),

            new AdditionExpression(

                new NumberExpression(2),

                new NumberExpression(3)

            )

        );

        // Evaluate the expression

        Context context = new Context();

        int result = expression.Interpret(context);

        Console.WriteLine("Result: " + result); // Output: 6

    }

}

In this example, `NumberExpression` represents a terminal expression, `AdditionExpression` represents a non-terminal expression, and `Context` provides any additional context needed during interpretation. The client builds an expression tree and initiates the interpretation, resulting in the output of the evaluated arithmetic expression.