blet, bletrec, bletseq macros

Technologicat · Technologicat · commit 8f658b03a3b5 · 2018-10-27T02:13:15.000+03:00
diff --git a/macro_extras/main.py b/macro_extras/main.py
@@ -13,6 +13,7 @@
                               simple_let, simple_letseq, \
                               let, letseq, letrec, \
                               dlet, dletseq, dletrec, \
+                              blet, bletseq, bletrec, \
                               do, do0, \
                               forall, insist, deny, forall_simple, \
                               aif, it, \
@@ -232,7 +233,7 @@ def add3(a, b, c):
     # decorator version: let over def
     @dlet((x, 0))
     def count():
-        x << x + 1
+        x << x + 1  # assigment to let environment uses the "assignment expr" syntax
         return x
     assert count() == 1
     assert count() == 2
@@ -249,9 +250,28 @@ def f(x):
     @dletseq((x, 1),
              (x, x+1),
              (x, x+2))
-    def g(*args, **kwargs):
+    def g(a):
+        return a + x
+    assert g(10) == 14
+
+    # block versions (def takes no args, runs immediately, replaced with return value)
+    @blet((x, 21))
+    def result():
+        return 2*x
+    assert result == 42
+
+    @bletseq((x, 1),
+             (x, x+1),
+             (x, x+2))
+    def result():
         return x
-    assert g() == 4
+    assert result == 4
+
+    @bletrec((evenp, lambda x: (x == 0) or oddp(x - 1)),
+             (oddp,  lambda x: (x != 0) and evenp(x - 1)))
+    def result():
+        return evenp(42)
+    assert result is True
 
     # TCO combo
     with tco:
diff --git a/unpythonic/let.py b/unpythonic/let.py
@@ -283,8 +283,8 @@ def decorated(*args, **kwargs):
         return decorated
     return deco
 
-def _blet(mode, **bindings):
-    dlet_deco = _dlet(mode, **bindings)
+def _blet(mode, _envname="env", **bindings):
+    dlet_deco = _dlet(mode, _envname, **bindings)
     def deco(body):
         return call(dlet_deco(body))
     return deco
diff --git a/unpythonic/lispylet.py b/unpythonic/lispylet.py
@@ -262,8 +262,8 @@ def decorated(*args, **kwargs):
         return decorated
     return deco
 
-def _blet(bindings, mode="let"):
-    dlet_deco = _dlet(bindings, mode)
+def _blet(bindings, mode="let", _envname="env"):
+    dlet_deco = _dlet(bindings, mode, _envname)
     def deco(body):
         return call(dlet_deco(body))
     return deco
diff --git a/unpythonic/syntax.py b/unpythonic/syntax.py
@@ -33,7 +33,8 @@
 from unpythonic.it import flatmap, uniqify, rev
 from unpythonic.fun import curry as curryf, _currycall as currycall, identity
 from unpythonic.dynscope import dyn
-from unpythonic.lispylet import letrec as letrecf, let as letf, _dlet as dletf
+from unpythonic.lispylet import letrec as letrecf, let as letf, \
+                                _dlet as dletf, _blet as bletf
 from unpythonic.seq import do as dof, begin as beginf
 from unpythonic.fup import fupdate
 from unpythonic.misc import namelambda
@@ -584,7 +585,7 @@ def count():
     **CAUTION**: assignment to the let environment is ``name << value``;
     the regular syntax ``name = value`` creates a local variable.
     """
-    return _dletimpl(tree, args, "let", gen_sym)
+    return _dletimpl(tree, args, "let", "decorate", gen_sym)
 
 @macros.decorator
 def dletrec(tree, args, *, gen_sym, **kw):
@@ -601,11 +602,38 @@ def f(x):
 
     Same cautions apply as to ``dlet``.
     """
-    return _dletimpl(tree, args, "letrec", gen_sym)
+    return _dletimpl(tree, args, "letrec", "decorate", gen_sym)
+
+@macros.decorator
+def blet(tree, args, *, gen_sym, **kw):
+    """[syntax, decorator] def --> let block.
+
+    Example::
+
+        @blet((x, 21))
+        def result():
+            return 2*x
+        assert result == 42
+    """
+    return _dletimpl(tree, args, "let", "call", gen_sym)
+@macros.decorator
+def bletrec(tree, args, *, gen_sym, **kw):
+    """[syntax, decorator] def --> letrec block.
+
+    Example::
+
+        @bletrec((evenp, lambda x: (x == 0) or oddp(x - 1)),
+                 (oddp,  lambda x: (x != 0) and evenp(x - 1)))
+        def result():
+            return evenp(42)
+        assert result is True
+    """
+    return _dletimpl(tree, args, "letrec", "call", gen_sym)
 
 # Very similar to _letimpl, but perhaps more readable to keep these separate.
-def _dletimpl(tree, args, mode, gen_sym):
+def _dletimpl(tree, args, mode, kind, gen_sym):
     assert mode in ("let", "letrec")
+    assert kind in ("decorate", "call")
 
     if not args:
         return tree
@@ -621,8 +649,9 @@ def _dletimpl(tree, args, mode, gen_sym):
         values = [t1(b) for b in values]
     tree = t2(tree)
 
+    letter = dletf if kind == "decorate" else bletf
     binding_pairs = [q[(u[k], ast_literal[v])] for k, v in zip(names, values)]
-    tree.decorator_list = tree.decorator_list + [hq[dletf((ast_literal[binding_pairs],), mode=u[mode], _envname=u[e])]]
+    tree.decorator_list = tree.decorator_list + [hq[letter((ast_literal[binding_pairs],), mode=u[mode], _envname=u[e])]]
     tree.args.kwonlyargs = tree.args.kwonlyargs + [arg(arg=e)]
     tree.args.kw_defaults = tree.args.kw_defaults + [None]
     return tree
@@ -632,7 +661,34 @@ def dletseq(tree, args, gen_sym, **kw):
     """[syntax, decorator] Decorator version of letseq, for 'letseq over def'.
 
     Expands to nested function definitions, each with one ``dlet`` decorator.
+
+    Example::
+
+        @dletseq((x, 1),
+                 (x, x+1),
+                 (x, x+2))
+        def g(a):
+            return a + x
+        assert g(10) == 14
     """
+    return _dletseqimpl(tree, args, "decorate", gen_sym)
+
+@macros.decorator
+def bletseq(tree, args, gen_sym, **kw):
+    """[syntax, decorator] def --> letseq block.
+
+    Example::
+
+        @bletseq((x, 1),
+                 (x, x+1),
+                 (x, x+2))
+        def result():
+            return x
+        assert result == 4
+    """
+    return _dletseqimpl(tree, args, "call", gen_sym)
+
+def _dletseqimpl(tree, args, kind, gen_sym):
     # What we want:
     #
     # @dletseq((x, 1),
@@ -655,19 +711,21 @@ def dletseq(tree, args, gen_sym, **kw):
     #   return g2()
     # assert g() == 4
     #
+    assert kind in ("decorate", "call")
     if not args:
         return tree
 
     userargs = tree.args  # original arguments to the def
     fname = tree.name
     noargs = arguments(args=[], kwonlyargs=[], vararg=None, kwarg=None,
                           defaults=[], kw_defaults=[])
-    iname = gen_sym("inner")
+    iname = gen_sym("{}_inner".format(fname))
     tree.args = noargs
     tree.name = iname
 
     *rest, last = args
-    innerdef = dlet.transform(tree, last)
+    dletter = dlet if kind == "decorate" else blet
+    innerdef = dletter.transform(tree, last)
 
     # optimization: in the final step, no need to generate a wrapper function
     if not rest:
@@ -679,12 +737,13 @@ def dletseq(tree, args, gen_sym, **kw):
         innerdef.args.kw_defaults += tmpargs.kw_defaults
         return innerdef
 
+    ret = Return(value=q[name[iname]()]) if kind == "decorate" else Return(value=q[name[iname]])
     outer = FunctionDef(name=fname, args=userargs,
-                        body=[innerdef, Return(value=q[name[iname]()])],
+                        body=[innerdef, ret],
                         decorator_list=[],
                         returns=None)  # no return type annotation
     outer = copy_location(outer, tree)
-    return dletseq.transform(outer, *rest)
+    return _dletseqimpl(outer, rest, kind, gen_sym)
 
 # -----------------------------------------------------------------------------
 
