arithmetic evaluator

Author: ramalho

mylis/mylis_3/environ.py

@@ -0,0 +1,37 @@
+import math
+import operator as op
+
+from .mytypes import Environment, Symbol
+
+
+def core_env() -> Environment:
+    "An environment for an s-expression calculator."
+    env: Environment = {}
+    env.update(vars(math))   # sin, cos, sqrt, pi, ...
+    env.update(
+        {
+            '+': 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

mylis/mylis_3/evaluator.py

@@ -0,0 +1,18 @@
+from typing import Any
+from .mytypes import Environment, Expression, Symbol
+
+
+def evaluate(x: 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)

mylis/mylis_3/evaluator_test.py

@@ -0,0 +1,49 @@
+from typing import Any
+
+from .environ import core_env
+from .evaluator import evaluate
+from .parser import parse
+from .mytypes import Environment
+
+from pytest import fixture, mark
+
+@fixture
+def std_env() -> Environment:
+    return core_env()
+
+
+def test_evaluate_variable() -> None:
+    env: Environment = dict(x=10)
+    source = 'x'
+    expected = 10
+    got = evaluate(parse(source), env)
+    assert got == expected
+
+
+def test_evaluate_literal(std_env: Environment) -> None:
+    source = '3.3'
+    expected = 3.3
+    got = evaluate(parse(source), std_env)
+    assert got == expected
+
+
+@mark.parametrize( 'source, expected', [
+    ('(* 11111 11111)', 123454321),
+    ('(* (+ 4 3) 6)', 42),
+    ('(sin (/ pi 2))', 1)
+])
+def test_evaluate_call(
+    std_env: Environment,
+    source: str,
+    expected: Any,
+) -> None:
+    got = evaluate(parse(source), std_env)
+    assert got == expected
+
+# Special forms
+
+def test_define(std_env: Environment) -> None:
+    source = '(define answer (* 6 7))'
+    got = evaluate(parse(source), std_env)
+    assert got is None
+    assert std_env['answer'] == 42

mylis/mylis_3/parser.py

@@ -5,11 +5,11 @@
 ## See http://norvig.com/lispy.html
 ## Refactorting and additions by Luciano Ramalho (2022)
 
-from .lis_types import (
+from .mytypes import (
     Atom,
+    ParserException,
     Symbol,
     Expression,
-    BlankExpression,
     BraceNeverClosed,
     UnexpectedCloseBrace,
 )
@@ -40,7 +40,7 @@ def read_from_tokens(tokens: list[str]) -> Expression:
     try:
         token = tokens.pop(0)
     except IndexError:
-        raise BlankExpression()
+        raise ParserException('Empty list of tokens')
     if token in BRACES:
         exp = []
         while tokens and tokens[0] != BRACES[token]:
@@ -66,9 +66,19 @@ def parse_atom(token: str) -> Atom:
             return Symbol(token)
 
 
-def lispstr(exp: object) -> str:
-    """Convert a Python object back into a Lisp-readable string."""
-    if isinstance(exp, list):
-        return '(' + ' '.join(map(lispstr, exp)) + ')'
-    else:
-        return str(exp)
+# s_expr is the inverse function of parse, but some formatting
+# is lost, and all braces are rendered as ()
+def s_expr(obj: object) -> str:
+    """ Convert Python object back to s-expression code. """
+    match obj:
+        case True:
+            return '#t'
+        case False:
+            return '#f'
+        case list(obj):
+            items = ' '.join(s_expr(x) for x in obj)
+            return f'({items})'
+        case Symbol(x):
+            return x
+        case _:
+            return repr(obj)

mylis/mylis_3/parser_test.py

@@ -1,11 +1,11 @@
-from .lis_types import (
-    BlankExpression,
+from email.parser import Parser
+from .mytypes import (
     Expression,
     ParserException,
     UnexpectedCloseBrace,
     BraceNeverClosed,
 )
-from .parser import parse
+from .parser import parse, s_expr
 
 from pytest import mark, raises
 
@@ -65,19 +65,36 @@ def test_parse_mixed_braces(source: str, expected: Expression) -> None:
 
 
 @mark.parametrize(
-    'source, expected, brace',
+    'source, expected, match',
     [
-        ('', BlankExpression, ''),
+        ('', ParserException, 'Empty'),
         ('{', BraceNeverClosed, '{'),
         ('([]', BraceNeverClosed, '('),
         ('(])', UnexpectedCloseBrace, ']'),
         ('([)', UnexpectedCloseBrace, ')'),
     ],
 )
 def test_parse_malformed(
-    source: str, expected: ParserException, brace: str
+    source: str, expected: ParserException, match: str
 ) -> None:
     with raises(expected) as excinfo:  # type: ignore
         parse(source)
-    if brace:
-        assert repr(brace) in str(excinfo.value)
+    assert match in str(excinfo.value)
+
+
+@mark.parametrize('obj, expected', [
+    (0, '0'),
+    (1, '1'),
+    (False, '#f'),
+    (True, '#t'),
+    (1.5, '1.5'),
+    ('sin', 'sin'),
+    (['+', 1, 2], '(+ 1 2)'),
+    (['if', ['<', 'a', 'b'], True, False], '(if (< a b) #t #f)'),
+    ([], '()'),
+    (None, 'None'),
+    (..., 'Ellipsis'),
+])
+def test_s_expr(obj: object, expected: str) -> None:
+    got = s_expr(obj)
+    assert got == expected