Impl conceptual interpreter pattern.

Author: ilopX

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/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, // false
+    Xor(
+      variable2, // false
+      Or(
+        variable3, // true
+        variable4, // false
+      ),
+    ),
+  );
+
+  print(expression.evaluate(context));
+  print(expression.toDebugString(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/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);
+}

patterns/interpreter/conceptual/variable/variable.dart

@@ -0,0 +1,19 @@
+import '../pattern/context.dart';
+import '../pattern/expression.dart';
+
+class BoolVariable implements Expression {
+  BoolVariable(this.name);
+
+  final String name;
+
+  @override
+  bool evaluate(Context context) {
+    return context.lookup(name);
+  }
+
+  @override
+  String toDebugString(Context context) {
+    final value = context.lookup(name);
+    return '$name($value)';
+  }
+}