+# Interpreter++## Description++If a problem occurs very often and requires long and repetitive steps to solve it,+then the problem instances might be expressed in a simple+language and inerpreter object could solve it by+interpreting the sentences written in this simple language.+Basically, for any kind of problems we define a domain+language, then define a grammar for this language and+design interpreter solving problem instances.++## Motivation++Imagine that our work is translating simple mathematical expressions into+[assembly language](https://en.wikipedia.org/wiki/Assembly_language)+(more simple and low level programming language).+For simplicity, our expressions consists of ten digits `0`,...,`9`,+four operations `+, -, /, *` and a pair of parenthesis `(, )`.+For example, expression `2 + 4` could be translated into++```ignore+mov eax, 2+mov ebx, 4+add eax, ebx+```++Our goal is to automate translating into assembly instructions+using the Interpreter design pattern. In other words, we want simply+provide the Interpreter with an expressions and get Assembly+language output. For example++```rust, ignore+x.interpret("7+3*(2-1)", &output);+```++We don't claim that output assembly code is exactly what modern compilers generate,+but it at least computes the expression correctly.+It is simpy an example of using Interpreter pattern.++## Solution 1++The grammar for a set of expressions over `0,...,9, +,-,*,/,(,)` is

+# Interpreter++## Description++If a problem occurs very often and requires long and repetitive steps to solve it,+then the problem instances might be expressed in a simple+language and inerpreter object could solve it by+interpreting the sentences written in this simple language.+Basically, for any kind of problems we define a domain+language, then define a grammar for this language and+design interpreter solving problem instances.++## Motivation++Imagine that our work is translating simple mathematical expressions into+[assembly language](https://en.wikipedia.org/wiki/Assembly_language)+(more simple and low level programming language).+For simplicity, our expressions consists of ten digits `0`,...,`9`,+four operations `+, -, /, *` and a pair of parenthesis `(, )`.+For example, expression `2 + 4` could be translated into++```ignore+mov eax, 2+mov ebx, 4+add eax, ebx+```++Our goal is to automate translating into assembly instructions+using the Interpreter design pattern. In other words, we want simply+provide the Interpreter with an expressions and get Assembly+language output. For example++```rust, ignore+x.interpret("7+3*(2-1)", &output);+```++We don't claim that output assembly code is exactly what modern compilers generate,+but it at least computes the expression correctly.+It is simpy an example of using Interpreter pattern.++## Solution 1++The grammar for a set of expressions over `0,...,9, +,-,*,/,(,)` is

+# Interpreter++## Description++If a problem occurs very often and requires long and repetitive steps to solve it,+then the problem instances might be expressed in a simple+language and inerpreter object could solve it by+interpreting the sentences written in this simple language.+Basically, for any kind of problems we define a domain+language, then define a grammar for this language and+design interpreter solving problem instances.++## Motivation++Imagine that our work is translating simple mathematical expressions into+[assembly language](https://en.wikipedia.org/wiki/Assembly_language)+(more simple and low level programming language).+For simplicity, our expressions consists of ten digits `0`,...,`9`,+four operations `+, -, /, *` and a pair of parenthesis `(, )`.+For example, expression `2 + 4` could be translated into++```ignore+mov eax, 2+mov ebx, 4+add eax, ebx+```++Our goal is to automate translating into assembly instructions+using the Interpreter design pattern. In other words, we want simply+provide the Interpreter with an expressions and get Assembly+language output. For example++```rust, ignore+x.interpret("7+3*(2-1)", &output);+```++We don't claim that output assembly code is exactly what modern compilers generate,+but it at least computes the expression correctly.+It is simpy an example of using Interpreter pattern.+

+# Interpreter++## Description++If a problem occurs very often and requires long and repetitive steps to solve it,+then the problem instances might be expressed in a simple+language and inerpreter object could solve it by+interpreting the sentences written in this simple language.+Basically, for any kind of problems we define a domain+language, then define a grammar for this language and+design interpreter solving problem instances.++## Motivation++Imagine that our work is translating simple mathematical expressions into+[assembly language](https://en.wikipedia.org/wiki/Assembly_language)+(more simple and low level programming language).+For simplicity, our expressions consists of ten digits `0`,...,`9`,+four operations `+, -, /, *` and a pair of parenthesis `(, )`.+For example, expression `2 + 4` could be translated into++```ignore+mov eax, 2+mov ebx, 4+add eax, ebx+```++Our goal is to automate translating into assembly instructions+using the Interpreter design pattern. In other words, we want simply+provide the Interpreter with an expressions and get Assembly+language output. For example++```rust, ignore+x.interpret("7+3*(2-1)", &output);+```++We don't claim that output assembly code is exactly what modern compilers generate,+but it at least computes the expression correctly.+It is simpy an example of using Interpreter pattern.++## Solution 1++The grammar for a set of expressions over `0,...,9, +,-,*,/,(,)` is++```ignore+exp -> exp + term+exp -> exp - term+exp -> term+term -> term * factor+term -> term / factor+term -> factor+factor -> ( exp )+factor -> 0 | 1| 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

+# Interpreter++## Description++If a problem occurs very often and requires long and repetitive steps to solve it,+then the problem instances might be expressed in a simple+language and inerpreter object could solve it by+interpreting the sentences written in this simple language.+Basically, for any kind of problems we define a domain+language, then define a grammar for this language and+design interpreter solving problem instances.++## Motivation++Imagine that our work is translating simple mathematical expressions into+[assembly language](https://en.wikipedia.org/wiki/Assembly_language)+(more simple and low level programming language).+For simplicity, our expressions consists of ten digits `0`,...,`9`,+four operations `+, -, /, *` and a pair of parenthesis `(, )`.+For example, expression `2 + 4` could be translated into++```ignore+mov eax, 2+mov ebx, 4+add eax, ebx+```++Our goal is to automate translating into assembly instructions+using the Interpreter design pattern. In other words, we want simply+provide the Interpreter with an expressions and get Assembly+language output. For example++```rust, ignore+x.interpret("7+3*(2-1)", &output);+```++We don't claim that output assembly code is exactly what modern compilers generate,+but it at least computes the expression correctly.+It is simpy an example of using Interpreter pattern.+

+# Interpreter++## Description++If a problem occurs very often and requires long and repetitive steps to solve it,+then the problem instances might be expressed in a simple+language and inerpreter object could solve it by+interpreting the sentences written in this simple language.+Basically, for any kind of problems we define a domain+language, then define a grammar for this language and+design interpreter solving problem instances.++## Motivation++Imagine that our work is translating simple mathematical expressions into+[assembly language](https://en.wikipedia.org/wiki/Assembly_language)+(more simple and low level programming language).+For simplicity, our expressions consists of ten digits `0`,...,`9`,+four operations `+, -, /, *` and a pair of parenthesis `(, )`.+For example, expression `2 + 4` could be translated into++```ignore+mov eax, 2+mov ebx, 4+add eax, ebx+```++Our goal is to automate translating into assembly instructions+using the Interpreter design pattern. In other words, we want simply+provide the Interpreter with an expressions and get Assembly

+# Interpreter++## Description++If a problem occurs very often and requires long and repetitive steps to solve it,+then the problem instances might be expressed in a simple+language and inerpreter object could solve it by

 conversion between arbitrary types.  ## See also -[Collections are smart pointers idiom](../idioms/deref.md).--[Documentation for `Deref` trait](https://doc.rust-lang.org/std/ops/trait.Deref.html).+- [Collections are smart pointers idiom](../idioms/deref.md).+- Delegation crates for less boilerplate like [delegate](https://crates.io/crates/delegate) or +  [ambassador](https://crates.io/crates/ambassador)

 conversion between arbitrary types.  ## See also -[Collections are smart pointers idiom](../idioms/deref.md).--[Documentation for `Deref` trait](https://doc.rust-lang.org/std/ops/trait.Deref.html).+- [Collections are smart pointers idiom](../idioms/deref.md).+- Delegation crates for less boilerplate like [delegate](https://crates.io/crates/delegate) or [ambassador](https://crates.io/crates/ambassador)

+# Interpreter++## Description++If a problem occurs very often and requires long and repetitive steps to solve it,+then the problem instances might be expressed in a simple+language and inerpreter object could solve it by+interpreting the sentences written in this simple language.+Basically, for any kind of problems we define a domain+language, then define a grammar for this language and+design interpreter solving problem instances.++## Motivation++Imagine that our work is translating simple mathematical expressions into+[assembly language](https://en.wikipedia.org/wiki/Assembly_language)+(more simple and low level programming language).+For simplicity, our expressions consists of ten digits `0`,...,`9`,+four operations `+, -, /, *` and a pair of parenthesis `(, )`.+For example, expression `2 + 4` could be translated into++```ignore+mov eax, 2+mov ebx, 4+add eax, ebx+```++Our goal is to automate translating into assembly instructions+using the Interpreter design pattern. In other words, we want simply+provide the Interpreter with an expressions and get Assembly+language output. For example++```rust, ignore+x.interpret("7+3*(2-1)", &output);+```++We don't claim that output assembly code is exactly what modern compilers generate,+but it at least computes the expression correctly.+It is simpy an example of using Interpreter pattern.++## Solution 1++The grammar for a set of expressions over `0,...,9, +,-,*,/,(,)` is++```ignore+exp -> exp + term+exp -> exp - term+exp -> term+term -> term * factor+term -> term / factor+term -> factor+factor -> ( exp )+factor -> 0 | 1| 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9+```++Our first approach is a standard one, simple implementation of+a recursive descent parser. The following code+doesn't have `struct` abstraction in order to keep code short.+The code panics when expression is syntactically wrong+(unbalanced parentheses or missing digit/operator for example).++```rust+fn token(input: &[u8], cur: usize) -> char {+    if cur < input.len() {+        input[cur] as char+    } else {+        '$' // End of line+    }+}++fn single_expr(input: &[u8], cur: &mut usize, out: &mut Vec<String>) {+    expr(input, cur, out);++    let ch = token(input, *cur);+    if ch != '$' {+        panic!("Unexpected symbol '{}', at {}", ch, *cur);+    }+}++fn expr(input: &[u8], cur: &mut usize, out: &mut Vec<String>) {+    term(input, cur, out);++    loop {+        let ch = token(input, *cur);+        if ch == '$' || (ch != '+' && ch != '-') {+            break;+        } else {+            *cur += 1;+            term(input, cur, out);+            translate(ch, out);+        }+    }+}++fn term(input: &[u8], cur: &mut usize, out: &mut Vec<String>) {+    factor(input, cur, out);++    loop {+        let ch = token(input, *cur);+        if ch == '$' || (ch != '*' && ch != '/') {+            break;+        } else {+            *cur += 1;+            factor(input, cur, out);+            translate(ch, out);+        }+    }+}++fn factor(input: &[u8], cur: &mut usize, out: &mut Vec<String>) {+    let ch = token(input, *cur);++    if ch.is_digit(10) {+        out.push(format!("push {}", ch));+    } else if ch == '(' {+        *cur += 1;+        expr(input, cur, out);++        let ch = token(input, *cur);+        if ch != ')' {+            panic!("Missing ')' at {}", *cur);+        }+    } else {+        panic!("Unexpected symbol '{}', at {}", ch, *cur);+    }++    *cur += 1;+}++fn translate(ch: char, out: &mut Vec<String>) {+    out.push(String::from("pop ebx"));

+# Interpreter++## Description++If a problem occurs very often and requires long and repetitive steps to solve it,+then the problem instances might be expressed in a simple+language and inerpreter object could solve it by+interpreting the sentences written in this simple language.+Basically, for any kind of problems we define a domain+language, then define a grammar for this language and+design interpreter solving problem instances.++## Motivation++Imagine that our work is translating simple mathematical expressions into+[assembly language](https://en.wikipedia.org/wiki/Assembly_language)+(more simple and low level programming language).+For simplicity, our expressions consists of ten digits `0`,...,`9`,+four operations `+, -, /, *` and a pair of parenthesis `(, )`.+For example, expression `2 + 4` could be translated into++```ignore+mov eax, 2+mov ebx, 4+add eax, ebx+```++Our goal is to automate translating into assembly instructions+using the Interpreter design pattern. In other words, we want simply+provide the Interpreter with an expressions and get Assembly+language output. For example++```rust, ignore+x.interpret("7+3*(2-1)", &output);+```++We don't claim that output assembly code is exactly what modern compilers generate,+but it at least computes the expression correctly.+It is simpy an example of using Interpreter pattern.++## Solution 1++The grammar for a set of expressions over `0,...,9, +,-,*,/,(,)` is++```ignore+exp -> exp + term+exp -> exp - term+exp -> term+term -> term * factor+term -> term / factor+term -> factor+factor -> ( exp )+factor -> 0 | 1| 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9+```++Our first approach is a standard one, simple implementation of+a recursive descent parser. The following code+doesn't have `struct` abstraction in order to keep code short.+The code panics when expression is syntactically wrong+(unbalanced parentheses or missing digit/operator for example).++```rust+fn token(input: &[u8], cur: usize) -> char {+    if cur < input.len() {+        input[cur] as char+    } else {+        '$' // End of line+    }+}++fn single_expr(input: &[u8], cur: &mut usize, out: &mut Vec<String>) {+    expr(input, cur, out);++    let ch = token(input, *cur);+    if ch != '$' {+        panic!("Unexpected symbol '{}', at {}", ch, *cur);+    }+}++fn expr(input: &[u8], cur: &mut usize, out: &mut Vec<String>) {+    term(input, cur, out);++    loop {+        let ch = token(input, *cur);+        if ch == '$' || (ch != '+' && ch != '-') {+            break;+        } else {+            *cur += 1;+            term(input, cur, out);+            translate(ch, out);+        }+    }+}++fn term(input: &[u8], cur: &mut usize, out: &mut Vec<String>) {+    factor(input, cur, out);++    loop {+        let ch = token(input, *cur);+        if ch == '$' || (ch != '*' && ch != '/') {+            break;+        } else {+            *cur += 1;+            factor(input, cur, out);+            translate(ch, out);+        }+    }+}++fn factor(input: &[u8], cur: &mut usize, out: &mut Vec<String>) {+    let ch = token(input, *cur);++    if ch.is_digit(10) {+        out.push(format!("push {}", ch));+    } else if ch == '(' {+        *cur += 1;+        expr(input, cur, out);++        let ch = token(input, *cur);+        if ch != ')' {+            panic!("Missing ')' at {}", *cur);+        }+    } else {+        panic!("Unexpected symbol '{}', at {}", ch, *cur);+    }++    *cur += 1;+}++fn translate(ch: char, out: &mut Vec<String>) {+    out.push(String::from("pop ebx"));