evaluate with pattern matching

ramalho · ramalho · commit 14de7eff5eb6 · 2022-04-14T14:27:07.000-03:00
diff --git a/mylis/mylis_3/evaluator.py b/mylis/mylis_3/evaluator.py
@@ -1,18 +1,24 @@
 from typing import Any
-from .mytypes import Environment, Expression, Symbol
 
+from .parser import s_expr
+from .mytypes import Environment, Expression, InvalidSyntax, Symbol, UndefinedSymbol
 
-def evaluate(x: Expression, env: Environment) -> Any:
+
+def evaluate(exp: Expression, env: Environment) -> Any:
     "Evaluate an expression in an environment."
-    if isinstance(x, Symbol):                    # variable reference
-        return env[x]
-    elif not isinstance(x, list):                # constant literal
-        return x
-    elif x[0] == 'define':                       # (define var exp)
-        _, var, exp = x
-        env[var] = evaluate(exp, env)
-    else:                                        # (proc arg...)
-        proc_exp, *args = x
-        proc = evaluate(proc_exp, env)
-        arg_values = [evaluate(exp, env) for exp in args]
-        return proc(*arg_values)
+    match exp:
+        case int(x) | float(x):                      # number literal
+            return x
+        case Symbol(var):                            # variable reference
+            try:
+                return env[var]
+            except KeyError as exc:
+                raise UndefinedSymbol(var) from exc
+        case ['define', Symbol(var), value_exp]:     # (define var exp)
+            env[var] = evaluate(value_exp, env)
+        case [op, *args]:                            # (op arg1...)
+            proc = evaluate(op, env)
+            values = [evaluate(arg, env) for arg in args]
+            return proc(*values)
+        case _:
+            raise InvalidSyntax(s_expr(exp))
diff --git a/mylis/mylis_3/evaluator_test.py b/mylis/mylis_3/evaluator_test.py
@@ -42,7 +42,7 @@ def test_evaluate_call(
 
 # Special forms
 
-def test_define(std_env: Environment) -> None:
+def test_define_variable(std_env: Environment) -> None:
     source = '(define answer (* 6 7))'
     got = evaluate(parse(source), std_env)
     assert got is None
diff --git a/mylis/mylis_3/mytypes.py b/mylis/mylis_3/mytypes.py
@@ -0,0 +1,51 @@
+from collections.abc import MutableMapping
+from typing import TypeAlias
+
+
+Symbol: TypeAlias = str
+Number: TypeAlias = int | float
+Atom: TypeAlias = int | float | Symbol
+Expression: TypeAlias = Atom | list  # type: ignore
+
+Environment = MutableMapping[Symbol, object]
+
+class InterpreterException(Exception):
+    """Generic interpreter exception."""
+
+    def __init__(self, value: str = ''):
+        self.value = value
+
+    def __str__(self) -> str:
+        msg = self.__class__.__doc__ or ''
+        if self.value:
+            msg = msg.rstrip('.')
+            if "'" in self.value:
+                value = self.value
+            else:
+                value = repr(self.value)
+            msg += f': {value}'
+        return msg
+
+
+class ParserException(InterpreterException):
+    """Generic exception while parsing."""
+
+
+class UnexpectedCloseBrace(ParserException):
+    """Unexpected close brace."""
+
+
+class BraceNeverClosed(ParserException):
+    """Open brace was never closed."""
+
+
+class EvaluatorException(InterpreterException):
+    """Exception while evaluating."""
+
+
+class InvalidSyntax(EvaluatorException):
+    """Invalid syntax."""
+
+
+class UndefinedSymbol(EvaluatorException):
+    """Undefined symbol."""
