refactored up to (define...)

ramalho · ramalho · commit f2aaaa7a2081 · 2022-12-04T12:23:10.000-03:00
diff --git a/mylis/mylis_3/environ.py b/mylis/mylis_3/environ.py
@@ -6,32 +6,31 @@
 
 def core_env() -> Environment:
     "An environment for an s-expression calculator."
-    # sin, cos, sqrt, pi, ...
-    env: Environment = {Symbol(name): obj for name, obj in vars(math).items()}
+    env: Environment = vars(math)  # sin, cos, sqrt, pi, ...
     env.update(
         {
-            Symbol('+'): op.add,
-            Symbol('-'): op.sub,
-            Symbol('*'): op.mul,
-            Symbol('/'): op.truediv,
-            Symbol('quotient'): op.floordiv,
-            Symbol('>'): op.gt,
-            Symbol('<'): op.lt,
-            Symbol('>='): op.ge,
-            Symbol('<='): op.le,
-            Symbol('='): op.eq,
-            Symbol('abs'): abs,
-            Symbol('begin'): lambda *x: x[-1],
-            Symbol('eq?'): op.is_,
-            Symbol('equal?'): op.eq,
-            Symbol('max'): max,
-            Symbol('min'): min,
-            Symbol('not'): op.not_,
-            Symbol('number?'): lambda x: isinstance(x, (int, float)),
-            Symbol('procedure?'): callable,
-            Symbol('modulo'): op.mod,
-            Symbol('round'): round,
-            Symbol('symbol?'): lambda x: isinstance(x, Symbol),
+            '+': op.add,
+            '-': op.sub,
+            '*': op.mul,
+            '/': op.truediv,
+            'quotient': op.floordiv,
+            '>': op.gt,
+            '<': op.lt,
+            '>=': op.ge,
+            '<=': op.le,
+            '=': op.eq,
+            'abs': abs,
+            'begin': lambda *x: x[-1],
+            'eq?': op.is_,
+            'equal?': op.eq,
+            'max': max,
+            'min': min,
+            'not': op.not_,
+            'number?': lambda x: isinstance(x, (int, float)),
+            'procedure?': callable,
+            'modulo': op.mod,
+            'round': round,
+            'symbol?': lambda x: isinstance(x, Symbol),
         }
     )
     return env
diff --git a/mylis/mylis_3/evaluator.py b/mylis/mylis_3/evaluator.py
@@ -3,6 +3,12 @@
 from .parser import s_expr
 from .mytypes import Environment, Expression, InvalidSyntax, Symbol, UndefinedSymbol
 
+KEYWORDS = 'define'.split()
+
+# Quantifiers in s-expression syntax comments:
+#   * : 0 or more
+#   + : 1 or more
+#   ? : 0 or 1
 
 def evaluate(exp: Expression, env: Environment) -> Any:
     "Evaluate an expression in an environment."
@@ -16,7 +22,7 @@ def evaluate(exp: Expression, env: Environment) -> Any:
                 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...)
+        case [op, *args] if op not in KEYWORDS:      # (op exp*)
             proc = evaluate(op, env)
             values = [evaluate(arg, env) for arg in args]
             return proc(*values)
diff --git a/mylis/mylis_3/evaluator_test.py b/mylis/mylis_3/evaluator_test.py
@@ -1,7 +1,8 @@
+import ast
 from typing import Any
 
 from .environ import core_env
-from .evaluator import evaluate
+from .evaluator import evaluate, KEYWORDS
 from .parser import parse
 from .mytypes import Environment, Symbol
 
@@ -47,3 +48,35 @@ def test_define_variable(std_env: Environment) -> None:
     got = evaluate(parse(source), std_env)
     assert got is None
     assert std_env[Symbol('answer')] == 42
+
+
+# TODO: consider moving test below as a self test in evaluator.py
+
+def test_declared_keywords():
+    """ Check that the set of KEYWORDS is the same as
+        the set of string constants in the first position of
+        sequence patterns in the match/case inside evaluate()
+    """
+    with open('evaluator.py') as source:
+        tree = ast.parse(source.read())
+
+    cases = None
+    for node in ast.walk(tree):
+        match node:
+            # find FunctionDef named 'evaluate'
+            case ast.FunctionDef(name='evaluate', body=[_,
+                        ast.Match(cases=cases)
+                    ]):
+                break
+    assert cases is not None
+
+    # collect string constants in the first position of sequence patterns
+    found_keywords = set()
+    for case in cases:
+        match case.pattern:
+            case ast.MatchSequence(
+                    patterns=[ast.MatchValue(ast.Constant(value=str(kw))), *_]):
+                found_keywords.add(kw)
+
+    found_keywords = sorted(found_keywords)
+    assert found_keywords == sorted(KEYWORDS)
diff --git a/mylis/mylis_3/mytypes.py b/mylis/mylis_3/mytypes.py
@@ -4,8 +4,7 @@
 
 # cannot use NewType because we need isinstance()
 # to support (symbol? x) in environ.py
-class Symbol(str):
-    pass  
+Symbol: TypeAlias = str
 Number: TypeAlias = int | float
 Atom: TypeAlias = int | float | Symbol
 Expression: TypeAlias = Atom | list  # type: ignore
