Interpreter Design Pattern in Scala

1. Definition

The Interpreter design pattern provides a way to evaluate language grammars or expressions for particular languages. It involves implementing an interpreter for a simple language, focusing on the representation of grammar rules as classes.

2. Problem Statement

Imagine you're developing a configuration tool that allows users to define rules or conditions using a simple domain-specific language (DSL). Implementing a custom parser and evaluator for this DSL can quickly become cumbersome and error-prone if not structured correctly.

3. Solution

The Interpreter pattern suggests representing each grammar rule as a separate class. These classes collaborate to interpret and evaluate expressions. Using object-oriented techniques, you can leverage polymorphism to interpret various types of expressions in a unified manner.

4. Real-World Use Cases

1. SQL parsers in databases.

2. Regular expression evaluators.

3. Rule-based engines.

5. Implementation Steps

1. Define an abstract syntax tree made up of many nodes. Each node corresponds to a grammar rule.

2. Implement an interpret method in these nodes.

3. Parse the input into this tree, and then call interpret on the root.

6. Implementation in Scala Programming

// Abstract Expression
trait Expression {
  def interpret(context: String): Boolean
// Terminal Expression
class TerminalExpression(data: String) extends Expression {
  def interpret(context: String): Boolean = context.contains(data)
// Or Expression
class OrExpression(expr1: Expression, expr2: Expression) extends Expression {
  def interpret(context: String): Boolean = expr1.interpret(context) || expr2.interpret(context)
// And Expression
class AndExpression(expr1: Expression, expr2: Expression) extends Expression {
  def interpret(context: String): Boolean = expr1.interpret(context) && expr2.interpret(context)
// Client and Tester
object InterpreterClient extends App {
  def getMaleExpression(): Expression = {
    val robert = new TerminalExpression("Robert")
    val john = new TerminalExpression("John")
    new OrExpression(robert, john)
  def getMarriedWomanExpression(): Expression = {
    val julie = new TerminalExpression("Julie")
    val married = new TerminalExpression("Married")
    new AndExpression(julie, married)
  val isMale = getMaleExpression()
  val isMarriedWoman = getMarriedWomanExpression()
  println("John is male? " + isMale.interpret("John"))
  println("Julie is a married woman? " + isMarriedWoman.interpret("Married Julie"))


John is male? true
Julie is a married woman? true


1. Different types of Expression objects represent different grammar rules.

2. TerminalExpression checks if the data is in the given context.

3. OrExpression and AndExpression combine other expressions.

4. The client constructs the abstract syntax tree by composing Expression objects.

5. The interpret method evaluates the expression against a string.

7. When to use?

Use the Interpreter pattern when:

1. There's a language you want to interpret with well-defined grammar.

2. Grammar is simple. For complex grammars, tools like parsers or compilers are more appropriate.

3. Efficiency is not a top priority, as interpreters can be slower than hand-tailored solutions.