Merge pull request #70 from ilopX/add-intepreter-pattern

Add intepreter pattern

Author: ilopX

CHANGELOG.md

@@ -1,3 +1,6 @@
+## 0.32.0
+- Add conceptual interpreter pattern.
+
 ## 0.31.0
 - Add conceptual proxy pattern.
 

README.md

@@ -12,7 +12,7 @@ It contains **Dart** examples for all classic **GoF** design patterns.
 - [ ]  **Behavioral**
     - [x] **Chain of Responsibility** - [[Server Middleware](https://github.com/RefactoringGuru/design-patterns-dart/tree/main/patterns/chain_of_responsibility/server_middleware)]
     - [x] **Command** - [[Text Editor](https://github.com/RefactoringGuru/design-patterns-dart/tree/main/patterns/command/text_editor)] 
-    - [ ] Interpreter
+    - [x] **Interpreter**  - [[Conceptual](https://github.com/RefactoringGuru/design-patterns-dart/tree/main/patterns/interpreter/conceptual)]
     - [ ] **Iterator**
     - [x] **Mediator** - [[Conceptual](https://github.com/RefactoringGuru/design-patterns-dart/tree/main/patterns/mediator/conceptual)]
     - [x] **Memento** - [[Conceptual](https://github.com/RefactoringGuru/design-patterns-dart/tree/main/patterns/memento/conceptual)] [[![16x16](https://user-images.githubusercontent.com/8049534/171852337-57db0faf-1f5e-489a-a79a-22ed4f47b4ed.png) Memento Editor](https://github.com/RefactoringGuru/design-patterns-dart/tree/main/patterns/memento/memento_editor)] 

patterns/interpreter/conceptual/README.md

@@ -0,0 +1,42 @@
+# Interpreter Pattern
+In computer programming, the interpreter pattern is a design pattern that specifies how to evaluate 
+sentences in a language. 
+
+## Diagram:
+![Interpreter Diagram](https://user-images.githubusercontent.com/8049534/176169636-4c8eb3ba-d5e8-4ecb-81a8-96f1a30f6339.png)
+
+## Client code:
+```dart
+void main() {
+  final context = Context();
+  final variable1 = BoolVariable('var1');
+  final variable2 = BoolVariable('var2');
+  final variable3 = BoolVariable('var3');
+  final variable4 = BoolVariable('var4');
+
+  context.assign(variable1, true);
+  context.assign(variable2, false);
+  context.assign(variable3, true);
+  context.assign(variable4, false);
+
+  final expression = And(
+    variable1, // true
+    Xor(
+      variable2, // false
+      Or(
+        variable3, // true
+        variable4, // false
+      ),
+    ),
+  );
+
+  print(expression.evaluate(context));
+  print(expression.toDebugString(context));
+}
+```
+
+### Output:
+```
+var4(false) Or var3(true) Xor var2(false) And var1(true)
+result: true
+```

patterns/interpreter/conceptual/main.dart

@@ -0,0 +1,32 @@
+import 'operations/and.dart';
+import 'operations/or.dart';
+import 'operations/xor.dart';
+import 'pattern/context.dart';
+import 'variable/bool_variable.dart';
+
+void main() {
+  final context = Context();
+  final variable1 = BoolVariable('var1');
+  final variable2 = BoolVariable('var2');
+  final variable3 = BoolVariable('var3');
+  final variable4 = BoolVariable('var4');
+
+  context.assign(variable1, true);
+  context.assign(variable2, false);
+  context.assign(variable3, true);
+  context.assign(variable4, false);
+
+  final expression = And(
+    variable1, // true
+    Xor(
+      variable2, // false
+      Or(
+        variable3, // true
+        variable4, // false
+      ),
+    ),
+  );
+
+  print(expression.toDebugString(context));
+  print('result: ${expression.evaluate(context)}');
+}

patterns/interpreter/conceptual/operations/and.dart

@@ -0,0 +1,8 @@
+import 'operation.dart';
+
+class And extends Operation {
+  And(super.expression1, super.expression2);
+
+  @override
+  bool operation(bool a, bool b) => a && b;
+}

patterns/interpreter/conceptual/operations/operation.dart

@@ -0,0 +1,25 @@
+import '../pattern/context.dart';
+import '../pattern/expression.dart';
+
+abstract class Operation implements Expression {
+  final Expression expression1;
+  final Expression expression2;
+
+  Operation(this.expression1, this.expression2);
+
+  bool operation(bool a, bool b);
+
+  @override
+  bool evaluate(Context context) {
+    final a = expression1.evaluate(context);
+    final b = expression2.evaluate(context);
+    return operation(a, b);
+  }
+
+  @override
+  String toDebugString(Context context) {
+    final a = expression1.toDebugString(context);
+    final b = expression2.toDebugString(context);
+    return '$b $runtimeType $a';
+  }
+}

patterns/interpreter/conceptual/operations/or.dart

@@ -0,0 +1,8 @@
+import 'operation.dart';
+
+class Or extends Operation {
+  Or(super.expression1, super.expression2);
+
+  @override
+  bool operation(bool a, bool b) => a || b;
+}

patterns/interpreter/conceptual/operations/xor.dart

@@ -0,0 +1,8 @@
+import 'operation.dart';
+
+class Xor extends Operation {
+  Xor(super.expression1, super.expression2);
+
+  @override
+  bool operation(bool a, bool b) => a ^ b;
+}

patterns/interpreter/conceptual/pattern/context.dart

@@ -0,0 +1,13 @@
+import '../variable/bool_variable.dart';
+
+class Context {
+  void assign(BoolVariable variable, bool value) {
+    _values.putIfAbsent(variable.name, () => value);
+  }
+
+  bool lookup(String name) {
+    return _values[name]!;
+  }
+
+  final _values = <String, bool>{};
+}

patterns/interpreter/conceptual/pattern/expression.dart

@@ -0,0 +1,7 @@
+import 'context.dart';
+
+abstract class Expression {
+  bool evaluate(Context context);
+
+  String toDebugString(Context context);
+}