refactor ecs to separate module

Technologicat · Technologicat · commit 2e8e481339f6 · 2018-07-31T15:35:05.000+03:00
diff --git a/tour.py b/tour.py
@@ -9,7 +9,8 @@
                        dyn,        \
                        let, letrec, dlet, dletrec, blet, bletrec, \
                        immediate, begin, begin0, lazy_begin, lazy_begin0, \
-                       trampolined, jump, looped, looped_over, SELF, setescape, escape
+                       trampolined, jump, looped, looped_over, SELF, \
+                       setescape, escape
 
 def dynscope_demo():
     assert dyn.a == 2
diff --git a/unpythonic/__init__.py b/unpythonic/__init__.py
@@ -22,6 +22,7 @@
 from .arity import *
 from .assignonce import *
 from .dynscope import *
+from .ec import *
 from .let import *        # no guarantees on evaluation order (before Python 3.6), nice syntax
 
 # guaranteed evaluation order, clunky syntax
diff --git a/unpythonic/ec.py b/unpythonic/ec.py
@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Escape continuations."""
+
+__all__ = ["escape", "setescape"]
+
+from functools import wraps
+
+class escape(Exception):
+    """Exception that essentially represents an escape continuation.
+
+    Use ``raise escape(value)`` to escape to the nearest (dynamically) surrounding
+    ``@setescape``. The @setescape'd function immediately terminates, returning
+    ``value``.
+
+    Trampolined functions may also use ``return escape(value)``; the trampoline
+    will then raise the exception (this is to make it work also with lambdas).
+
+    The optional ``tag`` parameter can be used to limit which ``@setescape``
+    points see this particular escape instance. Default is to be catchable
+    by any ``@setescape``.
+    """
+    def __init__(self, value, tag=None):
+        self.value = value
+        self.tag = tag
+
+def setescape(tag=None):
+    """Decorator. Mark function as exitable by ``raise escape(value)``.
+
+    In Lisp terms, this essentially captures the escape continuation (ec)
+    of the decorated function. The ec can then be invoked by raising escape(value).
+
+    To make this work with lambdas, in trampolined functions it is also legal
+    to ``return escape(value)``. The trampoline specifically detects ``escape``
+    instances, and performs the ``raise``.
+
+    Technically, this is a decorator factory; the optional tag parameter can be
+    used to catch only those escapes with the same tag. ``tag`` can be a single
+    value, or a tuple. Single value means catch that specific tag; tuple means
+    catch any of those tags. Default is None, i.e. catch all.
+
+    Multi-return using escape continuation::
+
+        @setescape()
+        def f():
+            def g():
+                raise escape("hello from g")  # the arg becomes the return value of f()
+                print("not reached")
+                return False
+            g()
+            print("not reached either")
+            return False
+        assert f() == "hello from g"
+
+    Escape from FP loop::
+
+        @setescape()  # no tag, catch any escape instance
+        def f():
+            @looped
+            def s(loop, acc=0, i=0):
+                if i > 5:
+                    return escape(acc)  # the argument becomes the return value of f()
+                return loop(acc + i, i + 1)
+            print("never reached")
+            return False
+        assert f() == 15
+
+    For more control, tagged escape::
+
+        @setescape("foo")
+        def foo():
+            @immediate
+            @setescape("bar")
+            def bar():
+                @looped
+                def s(loop, acc=0, i=0):
+                    if i > 5:
+                        return escape(acc, tag="foo")
+                    return loop(acc + i, i + 1)
+                print("never reached")
+                return False
+            print("never reached either")
+            return False
+        assert f() == 15
+    """
+    if tag is None:
+        tags = None
+    elif isinstance(tag, (tuple, list)):  # multiple tags
+        tags = set(tag)
+    else: # single tag
+        tags = set((tag,))
+
+    def decorator(f):
+        @wraps(f)
+        def decorated(*args, **kwargs):
+            try:
+                return f(*args, **kwargs)
+            except escape as e:
+                if tags is None or e.tag is None or e.tag in tags:
+                    return e.value
+                else:  # meant for someone else, pass it on
+                    raise
+        return decorated
+    return decorator
+
+def test():
+    # "multi-return" using escape continuation
+    @setescape()
+    def f():
+        def g():
+            raise escape("hello from g")  # the argument becomes the return value of f()
+            print("not reached")
+        g()
+        print("not reached either")
+    assert f() == "hello from g"
+
+    # tests with @looped in tco.py to prevent cyclic dependency
+
+    print("All tests PASSED")
+
+if __name__ == '__main__':
+    test()
diff --git a/unpythonic/tco.py b/unpythonic/tco.py
@@ -186,98 +186,16 @@ def baz():
       over fn.py's is the more natural syntax for the client code.
 """
 
-__all__ = ["SELF", "jump", "trampolined", "looped", "looped_over", "escape", "setescape"]
+__all__ = ["SELF", "jump", "trampolined", "looped", "looped_over"]
 
 from functools import wraps
 
 from unpythonic.misc import immediate
+from unpythonic.ec import escape
 
 # evil inspect dependency, used only to provide informative error messages.
 from unpythonic.arity import arity_includes, UnknownArity
 
-# mainly for use with the looping constructs
-class escape(Exception):
-    """Exception that essentially represents an escape continuation.
-
-    Use ``raise escape(value)`` to escape to the nearest (dynamically) surrounding
-    ``@setescape``. The @setescape'd function immediately terminates, returning
-    ``value``.
-
-    Trampolined functions may also use ``return escape(value)``; the trampoline
-    will then raise the exception (this is to make it work also with lambdas).
-
-    The optional ``tag`` parameter can be used to limit which ``@setescape``
-    points see this particular escape instance. Default is to be catchable
-    by any ``@setescape``.
-    """
-    def __init__(self, value, tag=None):
-        self.value = value
-        self.tag = tag
-
-# mainly for use with the looping constructs
-def setescape(tag=None):
-    """Decorator. Mark function as exitable by ``raise escape(value)``.
-
-    In Lisp terms, this essentially captures the escape continuation (ec)
-    of the decorated function. The ec can then be invoked by raising escape(value).
-
-    To make this work with lambdas, in trampolined functions it is also legal
-    to ``return escape(value)``. The trampoline specifically detects ``escape``
-    instances, and performs the ``raise``.
-
-    Technically, this is a decorator factory; the optional tag parameter can be
-    used to catch only those escapes with the same tag. ``tag`` can be a single
-    value, or a tuple. Single value means catch that specific tag; tuple means
-    catch any of those tags. Default is None, i.e. catch all.
-
-    Example::
-
-        @setescape()  # no tag, catch any escape instance
-        def f():
-            @looped
-            def s(loop, acc=0, i=0):
-                if i > 5:
-                    return escape(acc)  # the argument becomes the return value of f()
-                return loop(acc + i, i + 1)
-            print("never reached")
-        assert f() == 15
-
-    Tagged escape::
-
-        @setescape("foo")
-        def foo():
-            @immediate
-            @setescape("bar")
-            def bar():
-                @looped
-                def s(loop, acc=0, i=0):
-                    if i > 5:
-                        return escape(acc, tag="foo")
-                    return loop(acc + i, i + 1)
-                print("never reached")
-            print("never reached either")
-        assert f() == 15
-    """
-    if tag is None:
-        tags = None
-    elif isinstance(tag, (tuple, list)):  # multiple tags
-        tags = set(tag)
-    else: # single tag
-        tags = set((tag,))
-
-    def decorator(f):
-        @wraps(f)
-        def decorated(*args, **kwargs):
-            try:
-                return f(*args, **kwargs)
-            except escape as e:
-                if tags is None or e.tag is None or e.tag in tags:
-                    return e.value
-                else:  # meant for someone else, pass it on
-                    raise
-        return decorated
-    return decorator
-
 @immediate  # immediate a class to make a singleton
 class SELF:  # sentinel, could be any object but we want a nice __repr__.
     def __repr__(self):
@@ -668,25 +586,17 @@ def baz():
                      e.evenp(10000))
     assert t is True
 
-    # "multi-return" using escape continuation
-    @setescape()
-    def f():
-        def g():
-            raise escape("hello from g")  # the argument becomes the return value of f()
-            print("not reached")
-        g()
-        print("not reached either")
-    assert f() == "hello from g"
-
     # escape surrounding function from inside FP loop
+    from unpythonic.ec import setescape
     @setescape()
     def f():
         @looped
         def s(loop, acc=0, i=0):
             if i > 5:
                 return escape(acc)  # trampolined functions may also "return escape(...)"
             return loop(acc + i, i + 1)
-        print("never reached")
+        print("not reached")
+        return False
     assert f() == 15
 
     # setescape point tag can be single value or tuple (tuples OR'd, like isinstance())
