enh: lazify now works with continuations, too

Technologicat · Technologicat · commit 79ef391a7500 · 2019-02-13T14:41:14.000+02:00
diff --git a/unpythonic/fun.py b/unpythonic/fun.py
@@ -304,7 +304,8 @@ def apply(f, arg0, *more, **kwargs):
         lst = tuple(more[-1])
     return lazycall(f, *(args + lst), **kwargs)
 
-@mark_lazy
+# Not marking this as lazy-aware works better with continuations (since this
+# is the default cont, and return values should be values, not lazy[])
 def identity(*args):
     """Identity function.
 
diff --git a/unpythonic/lazyutil.py b/unpythonic/lazyutil.py
@@ -32,7 +32,7 @@ def mark_lazy(f):
 
 def islazy(f):
     """Internal. Return whether the function f is marked as lazy."""
-    # special-case the expanded let form to support the lazify/curry combo
+    # special-case "_let" for lazify/curry combo when let[] expressions are present
     return hasattr(f, "_lazy") or (hasattr(f, "__name__") and f.__name__ == "_let")
 
 def lazycall(f, *thunks, **kwthunks):
diff --git a/unpythonic/syntax/__init__.py b/unpythonic/syntax/__init__.py
@@ -1669,8 +1669,6 @@ def g(x):
 
     **CAUTION**: Argument passing by function call, and let-bindings are
     currently the only binding constructs to which auto-lazification is applied.
-
-    **CAUTION**: This macro is experimental, not intended for production use.
     """
     with dyn.let(gen_sym=gen_sym):
         return (yield from _lazify(body=tree))
diff --git a/unpythonic/syntax/tailtools.py b/unpythonic/syntax/tailtools.py
@@ -31,6 +31,7 @@
 from ..it import uniqify
 from ..fun import identity
 from ..tco import trampolined, jump
+from ..lazyutil import islazy, mark_lazy
 
 # -----------------------------------------------------------------------------
 # Implicit return. This performs a tail-position analysis of function bodies.
@@ -127,6 +128,7 @@ def chain_conts(cc1, cc2, with_star=False):  # cc1=_pcc, cc2=cc
     """Internal function, used in code generated by the continuations macro."""
     if with_star:  # to be chainable from a tail call, accept a multiple-values arglist
         if cc1 is not None:
+            @mark_lazy
             def cc(*value):
                 return jump(cc1, cc=cc2, *value)
         else:
@@ -137,12 +139,14 @@ def cc(*value):
             cc = cc2
     else:  # for inert data value returns (this produces the multiple-values arglist)
         if cc1 is not None:
+            @mark_lazy
             def cc(value):
                 if isinstance(value, tuple):
                     return jump(cc1, cc=cc2, *value)
                 else:
                     return jump(cc1, value, cc=cc2)
         else:
+            @mark_lazy
             def cc(value):
                 if isinstance(value, tuple):
                     return jump(cc2, *value)
diff --git a/unpythonic/syntax/test/test_lazify.py b/unpythonic/syntax/test/test_lazify.py
@@ -5,7 +5,8 @@
 from ...it import flatten
 from ...collections import frozendict
 
-from ...syntax import macros, lazify, lazyrec, let, letseq, letrec, curry, local
+from ...syntax import macros, lazify, lazyrec, let, letseq, letrec, curry, local, \
+                              continuations, call_cc
 from ...syntax import force
 
 # doesn't really override the earlier curry import, the first one went into MacroPy's macro registry
@@ -323,9 +324,8 @@ def derp(a, b, c):
         assert apply(derp, 1, 2, (3/0,)) == (1, 2)
 
     # introducing the HasThon programming language (it has 100% more Thon than popular brands)
-#    with curry, lazify:
-    with lazify:
-      with curry:
+    # If you want a continuation-enabled HasThon, use "with continuations, curry, lazify".
+    with curry, lazify:
         def add3(a, b, c):
             return a + b + c
         assert add3(1)(2)(3) == 6
@@ -342,4 +342,32 @@ def f(a, b):
         assert letrec[((c, 42), (d, 1/0), (e, 2*c)) in [local[x << f(e)(d)],
                                                         x/2]] == 42
 
+    # works also with continuations
+    #  - also conts are transformed into lazy functions
+    #  - cc built by chain_conts is treated as lazy, **itself**; then it's up to
+    #    the continuations chained by it to decide whether to force their args.
+    #  - the default cont ``identity`` is strict, so it will force return values
+    with continuations, lazify:
+        k = None
+        def setk(*args, cc):
+            nonlocal k
+            k = cc
+            return args[0]
+        def doit():
+            lst = ['the call returned']
+            *more, = call_cc[setk('A', 1/0)]  # <-- this 1/0 goes into setk's args
+            return lst + [more[0]]
+        assert doit() == ['the call returned', 'A']
+        # We can now send stuff into k, as long as it conforms to the
+        # signature of the assignment targets of the "call_cc".
+        assert k('again') == ['the call returned', 'again']
+        # beware; if the cont tries to read the 1/0, that will lead to lots of
+        # head-scratching, as the error will appear to come from this line
+        # with no further debug info. (That's a limitation of the CPS conversion
+        # technique combined with Python's insistence that there must be a line
+        # and column in the original source file where the error occurred.)
+        #
+        # this 1/0 is sent directly into "more", as the call_cc returns again
+        assert k('thrice', 1/0) == ['the call returned', 'thrice']
+
     print("All tests PASSED")
diff --git a/unpythonic/tco.py b/unpythonic/tco.py
@@ -131,7 +131,9 @@ def baz():
 from sys import stderr
 
 from .regutil import register_decorator
+from .lazyutil import islazy, mark_lazy, force, lazycall
 
+@mark_lazy
 def jump(target, *args, **kwargs):
     """A jump (noun, not verb).
 
@@ -149,7 +151,7 @@ def jump(target, *args, **kwargs):
         **kwargs:
             Named arguments to be passed to  `target`.
     """
-    return _jump(target, args, kwargs)
+    return _jump(force(target), args, kwargs)
 
 class _jump:
     """The actual class representing a jump.
@@ -237,7 +239,7 @@ def trampoline(*args, **kwargs):
         f = function
         while True:
             if callable(f):  # general case
-                v = f(*args, **kwargs)
+                v = lazycall(f, *args, **kwargs)
             else:  # inert-data return value from call_ec or similar
                 v = f
             if isinstance(v, _jump):
@@ -259,6 +261,8 @@ def trampoline(*args, **kwargs):
     if callable(function):
         # fortunately functions in Python are just objects; stash for jump constructor
         trampoline._entrypoint = function
+        if islazy(function):
+            trampoline = mark_lazy(trampoline)
         return trampoline
     else:  # return value from call_ec or similar do-it-now decorator
         return trampoline()
