mylis_2: tail-call optimization implemented

Author: ramalho

mylis/mylis_2/examples/fact-iter.scm

@@ -0,0 +1,8 @@
+(define (! n)
+    (factorial-iter n 1))
+
+(define (factorial-iter n product)
+    (if (= n 1)
+        product
+        (factorial-iter (- n 1) (* n product))))
+(display (! x))

mylis/mylis_2/lis.py

@@ -22,6 +22,8 @@
 Atom: TypeAlias = int | float | Symbol
 Expression: TypeAlias = Atom | list
 
+TCO_ENABLED = True
+
 
 class Environment(ChainMap):
     def change(self, key: Symbol, value: object):
@@ -227,16 +229,16 @@ def evaluate(exp: Expression, env: Environment) -> Any:
             case [op, *args] if op not in KEYWORDS:             # (proc arg...)
                 proc = evaluate(op, env)
                 values = (evaluate(arg, env) for arg in args)
-                # if isinstance(proc, Procedure):
-                #     exp = ['begin', proc.body]
-                #     local_env = dict(zip(proc.parms, values))
-                #     env = Environment(local_env, proc.env)
-                # else:
-                try:
-                    return proc(*values)
-                except TypeError as exc:
-                    msg = f'{exc!r} invoking {proc!r}({args!r}): {lispstr(exp)}\nAST={exp!r}'
-                    raise EvaluatorException(msg) from exc
+                if TCO_ENABLED and isinstance(proc, Procedure):
+                     exp = ['begin', *proc.body]
+                     local_env = dict(zip(proc.parms, values))
+                     env = Environment(local_env, proc.env)
+                else:
+                    try:
+                        return proc(*values)
+                    except TypeError as exc:
+                        msg = f'{exc!r} invoking {proc!r}({args!r}): {lispstr(exp)}\nAST={exp!r}'
+                        raise EvaluatorException(msg) from exc
             case _:
                 raise InvalidSyntax(lispstr(exp))
 

mylis/mylis_2/lis_test.py

@@ -1,4 +1,4 @@
-import io
+import math
 from exceptions import InvalidSyntax
 
 from pytest import mark, fixture, raises
@@ -167,36 +167,25 @@ def test_begin(std_env: Environment) -> None:
     assert got == 42
 
 
-def test_invocation_builtin_car(std_env: Environment) -> None:
+def test_call_builtin_car(std_env: Environment) -> None:
     source = '(car (quote (11 22 33)))'
     got = evaluate(parse(source), std_env)
     assert got == 11
 
 
-def test_invocation_builtin_append(std_env: Environment) -> None:
+def test_call_builtin_append(std_env: Environment) -> None:
     source = '(append (quote (a b)) (quote (c d)))'
     got = evaluate(parse(source), std_env)
     assert got == ['a', 'b', 'c', 'd']
 
 
-def test_invocation_builtin_map(std_env: Environment) -> None:
+def test_call_builtin_map(std_env: Environment) -> None:
     source = '(map (lambda (x) (* x 2)) (quote (1 2 3))))'
     got = evaluate(parse(source), std_env)
     assert got == [2, 4, 6]
 
 
-def test_invocation_user_procedure(std_env: Environment) -> None:
-    source = """
-        (begin
-            (define max (lambda (a b) (if (>= a b) a b)))
-            (max 22 11)
-        )
-        """
-    got = evaluate(parse(source), std_env)
-    assert got == 22
-
-
-def test_define_function(std_env: Environment) -> None:
+def test_define_procedure(std_env: Environment) -> None:
     source = '(define (max a b) (if (>= a b) a b))'
     got = evaluate(parse(source), std_env)
     assert got is None
@@ -209,6 +198,17 @@ def test_define_function(std_env: Environment) -> None:
     assert max_fn(3, 2) == 3
 
 
+def test_call_user_procedure(std_env: Environment) -> None:
+    source = """
+        (begin
+            (define max (lambda (a b) (if (>= a b) a b)))
+            (max 22 11)
+        )
+        """
+    got = evaluate(parse(source), std_env)
+    assert got == 22
+
+
 def test_cond(std_env: Environment) -> None:
     source = """
         (cond ((> x 0) x)
@@ -262,4 +262,66 @@ def test_or(source: str, expected: Expression) -> None:
 ])
 def test_and(source: str, expected: Expression) -> None:
     got = evaluate(parse(source), {})
-    assert got == expected
+    assert got == expected
+
+############### tail-call optimization (TCO)
+
+def test_simple_user_procedure_call(std_env: Environment) -> None:
+    source = """
+        (begin
+            (define (answer) 42)
+            (answer)
+        )
+        """
+    got = evaluate(parse(source), std_env)
+    assert got == 42
+
+
+@fixture
+def tco(request):
+    import lis
+    initial_tco_setting = lis.TCO_ENABLED
+    marker = request.node.get_closest_marker('tail_call_optimization')
+    tco_flag = marker.args[0]
+    assert tco_flag in (True, False)
+    lis.TCO_ENABLED = tco_flag
+    yield
+    lis.TCO_ENABLED = initial_tco_setting
+
+
+@mark.tail_call_optimization(True)
+def test_tail_call_countdown(std_env: Environment, tco) -> None:
+    countdown_scm = """
+        (define (countdown n)
+            (if (= n 0)
+                0
+                (countdown (- n 1))))
+    """
+    evaluate(parse(countdown_scm), std_env)
+    # maximum with TCO: n=475; without TCO: n=316
+    n = 475
+    source = f'(countdown {n})'
+    got = evaluate(parse(source), std_env)
+    assert got == 0
+
+
+@mark.tail_call_optimization(True)
+def test_tail_call_factorial(std_env: Environment, tco) -> None:
+    factorial_scm = """
+    (begin
+        (define (factorial n)
+            (factorial-iter n 1))
+
+        (define (factorial-iter n product)
+            (if (= n 1)
+                product
+                (factorial-iter (- n 1) (* n product))))
+    )
+    """
+    evaluate(parse(factorial_scm), std_env)
+    import lis
+    # maximum with TCO: n=475; without TCO: n=316
+    n = 475
+    source = f'(factorial {n})'
+    got = evaluate(parse(source), std_env)
+    assert got == math.prod(range(2, n + 1))

mylis/mylis_2/mylis_test.py

@@ -121,24 +121,6 @@ def test_variadic_comparison(source: str, expected: lis.Expression) -> None:
     assert got == expected
 
 
-############### tail-call optimization (TCO)
-
-@mark.skip('requires TCO for n > 159')
-def test_tail_call() -> None:
-    factorial_scm = """
-        (define (! n)
-            (if (<= n 1)
-                1
-                (* n (! (- n 1)))))
-    """
-    env = standard_env()
-    lis.evaluate(lis.parse(factorial_scm), env)
-    n = 200   # maximum without TCO: n = 159
-    source = f'(! {n})'
-    got = lis.evaluate(lis.parse(source), env)
-    assert got == math.prod(range(2, n+1))
-
-
 ############### multi-line REPL
 
 
@@ -250,8 +232,9 @@ def test_repl_gcd_example_multiline(capsys):
     assert dlg.session == normalize(captured.out)
 
 
-# Note: flip-flop is defined as with shared closure,
-# there is no "maker" function surrounding it.
+# Note: flip-flop keep state in a global variable
+# because lis.py has no `let` form, and there is
+# no "maker" function surrounding the function.
 # Contrast with make-counter in examples_test.py
 # where each call to (make-counter) creates a new procedure
 # with its own closure.

pytest.ini

@@ -1,2 +1,4 @@
 [pytest]
 addopts = --doctest-modules
+markers =
+    tail_call_optimization: enable or disable TCO