let: new alternate haskelly syntax let[((k0, v0), ...) in body] and let[body, where((k0, v0), ...)]; remove let0 (now subsumed by the new syntax)

Technologicat · Technologicat · commit b5aefb1ea257 · 2018-12-11T13:42:03.000+02:00
diff --git a/unpythonic/syntax/__init__.py b/unpythonic/syntax/__init__.py
@@ -19,14 +19,14 @@
                          quicklambda as _quicklambda, f, _
 from .letdo import do as _do, do0 as _do0, local, \
                    let as _let, letseq as _letseq, letrec as _letrec, \
-                   let0 as _let0, letseq0 as _letseq0, letrec0 as _letrec0, \
                    dlet as _dlet, dletseq as _dletseq, dletrec as _dletrec, \
                    blet as _blet, bletseq as _bletseq, bletrec as _bletrec
 from .letsyntax import let_syntax_expr, let_syntax_block, block, expr
 from .prefix import prefix as _prefix
 from .tailtools import autoreturn as _autoreturn, tco as _tco, \
                        continuations as _continuations, with_cc
 
+from .util import UnexpandedLetView
 from ..dynassign import dyn, make_dynvar
 
 from macropy.core.macros import Macros
@@ -160,16 +160,26 @@ def let(tree, args, *, gen_sym, **kw):
 
     Usage::
 
-        let(bindings)[body]
-        let(bindings)[[body0, ...]]
+        let((k0, v0), ...)[body]
+        let((k0, v0), ...)[[body0, ...]]
 
-    where ``bindings`` is a comma-separated sequence of pairs ``(name, value)``
-    and ``body`` is an expression. The names bound by ``let`` are local;
+    where ``body`` is an expression. The names bound by ``let`` are local;
     they are available in ``body``, and do not exist outside ``body``.
 
-    For a body with multiple expressions, use an extra set of brackets.
-    This inserts a ``do``. Only the outermost extra brackets are interpreted
-    specially; all others in the bodies are interpreted as usual, as lists.
+    Alternative haskelly syntax is also available::
+
+        let[((k0, v0), ...) in body]
+        let[((k0, v0), ...) in [body0, ...]]
+        let[body, where((k0, v0), ...)]
+        let[[body0, ...], where((k0, v0), ...)]
+
+    For a body with multiple expressions, use an extra set of brackets,
+    as shown above. This inserts a ``do``. Only the outermost extra brackets
+    are interpreted specially; all others in the bodies are interpreted
+    as usual, as lists.
+
+    Note that in the haskelly syntax, the extra brackets for a multi-expression
+    body should enclose only the ``body`` part.
 
     Each ``name`` in the same ``let`` must be unique.
 
@@ -199,7 +209,7 @@ def let(tree, args, *, gen_sym, **kw):
           is applied first to ``[body0, ...]``, and the result becomes ``body``.
     """
     with dyn.let(gen_sym=gen_sym):
-        return _let(bindings=args, body=tree)
+        return _destructure_and_apply_let(tree, args, _let)
 
 @macros.expr
 def letseq(tree, args, *, gen_sym, **kw):
@@ -211,7 +221,7 @@ def letseq(tree, args, *, gen_sym, **kw):
     Expands to nested ``let`` expressions.
     """
     with dyn.let(gen_sym=gen_sym):
-        return _letseq(bindings=args, body=tree)
+        return _destructure_and_apply_let(tree, args, _letseq)
 
 @macros.expr
 def letrec(tree, args, *, gen_sym, **kw):
@@ -228,55 +238,14 @@ def letrec(tree, args, *, gen_sym, **kw):
     This is useful for locally defining mutually recursive functions.
     """
     with dyn.let(gen_sym=gen_sym):
-        return _letrec(bindings=args, body=tree)
-
-# -----------------------------------------------------------------------------
-# Inverted let, for situations where a body-first style improves readability.
-
-@macros.expr
-def let0(tree, *, gen_sym, **kw):
-    """[syntax, expr] Inverted let.
-
-    Because sometimes it is more readable to give the body first.
-
-    Usage::
-
-        let0[body, where((k0, v0), ...)]
-        let0[[body0, ...], where((k0, v0), ...)]
-
-    The ``where`` is literal.
-
-    Use extra brackets around the body (only) for multiple-expression mode
-    (a.k.a. implicit ``do[]``).
-
-    Inspired by Haskell's ``where``; this format is also common in mathematics.
-    """
-    with dyn.let(gen_sym=gen_sym):
-        return _let0(tree)
-
-@macros.expr
-def letseq0(tree, *, gen_sym, **kw):
-    """[syntax, expr] Inverted letseq.
-
-    Usage::
-
-        letseq0[body, where((k0, v0), ...)]
-        letseq0[[body0, ...], where((k0, v0), ...)]
-    """
-    with dyn.let(gen_sym=gen_sym):
-        return _letseq0(tree)
-
-@macros.expr
-def letrec0(tree, *, gen_sym, **kw):
-    """[syntax, expr] Inverted letrec.
-
-    Usage::
-
-        letrec0[body, where((k0, v0), ...)]
-        letrec0[[body0, ...], where((k0, v0), ...)]
-    """
-    with dyn.let(gen_sym=gen_sym):
-        return _letrec0(tree)
+        return _destructure_and_apply_let(tree, args, _letrec)
+
+def _destructure_and_apply_let(tree, args, expander):
+    if args:
+        return expander(bindings=args, body=tree)
+    # haskelly syntax
+    view = UnexpandedLetView(tree)  # note this gets only the part inside the brackets
+    return expander(bindings=view.bindings, body=view.body)
 
 # -----------------------------------------------------------------------------
 # Decorator versions, for "let over def".
diff --git a/unpythonic/syntax/letdo.py b/unpythonic/syntax/letdo.py
@@ -130,34 +130,6 @@ def envwrap(tree, envname):
     lam.args.args = [arg(arg=envname)]  # lambda e44: ...
     return lam
 
-# -----------------------------------------------------------------------------
-# Inverted let, for situations where a body-first style improves readability.
-#    let0[body, where((k0, v0), ...)]
-#    let0[[body0, ...], where((k0, v0), ...)]
-def _validate_let0(tree, myname):
-    if not (type(tree) is Tuple and len(tree.elts) == 2 and
-            type(tree.elts[1]) is Call and \
-            type(tree.elts[1].func) is Name and tree.elts[1].func.id == "where"):
-        assert False, "expected {}[body, where((k0, v0), ...)]".format(myname)
-
-def _let0_body(tree):  # single expr, or list for implicit do
-    return tree.elts[0]
-
-def _let0_bindings(tree):  # list [(k0, v0), ...]
-    return tree.elts[1].args
-
-def let0(tree):
-    _validate_let0(tree, "let0")
-    return let(bindings=_let0_bindings(tree), body=_let0_body(tree))
-
-def letseq0(tree):
-    _validate_let0(tree, "letseq0")
-    return letseq(bindings=_let0_bindings(tree), body=_let0_body(tree))
-
-def letrec0(tree):
-    _validate_let0(tree, "letrec0")
-    return letrec(bindings=_let0_bindings(tree), body=_let0_body(tree))
-
 # -----------------------------------------------------------------------------
 # Decorator versions, for "let over def".
 
diff --git a/unpythonic/syntax/prefix.py b/unpythonic/syntax/prefix.py
@@ -9,7 +9,7 @@
 from macropy.core.quotes import macros, q, u, ast_literal
 from macropy.core.walkers import Walker
 
-from .util import islet, isletsyntax, isdo
+from .util import islet, isdo, UnexpandedLetView, UnexpandedDoView
 
 from ..it import flatmap, rev, uniqify
 
@@ -20,26 +20,27 @@ def prefix(block_body):
     @Walker
     def transform(tree, *, quotelevel, set_ctx, stop, **kw):
         # Not tuples but syntax: leave alone the:
-        #  - bindings blocks of let, letseq, letrec, and the d*, b* variants
+        #  - binding pair "tuples" of let, letseq, letrec, their d*, b* variants,
+        #    and let_syntax, abbrev
         #  - subscript part of an explicit do[], do0[]
         # but recurse inside them.
         #
         # let and do have not expanded yet when prefix runs (better that way!).
-        if islet(tree, expanded=False) or isletsyntax(tree):
-            # let((x, 42))[...] appears as Subscript(value=Call(...), ...);
-            # we automatically recurse in other parts of the Subscript.
-            # Here we only need to treat how to proceed inside the Call part.
+        if islet(tree, expanded=False):
             stop()
-            for binding in tree.args:  # TODO: kwargs support for let(x=42)[...] if implemented later
+            view = UnexpandedLetView(tree)
+            for binding in view.bindings:
                 if type(binding) is not Tuple:
                     assert False, "prefix: expected a tuple in let binding position"
                 _, value = binding.elts  # leave name alone, recurse into value
                 binding.elts[1] = transform.recurse(value, quotelevel=quotelevel)
+            if view.body:
+                view.body = transform.recurse(view.body, quotelevel=quotelevel)
             return tree
         elif isdo(tree, expanded=False):
             stop()
-            tree.slice.value.elts = [transform.recurse(expr, quotelevel=quotelevel)
-                                       for expr in tree.slice.value.elts]
+            view = UnexpandedDoView(tree)
+            view.body = [transform.recurse(expr, quotelevel=quotelevel) for expr in view.body]
             return tree
         # general case
         # macro-created nodes might not have a ctx, but we run in the first pass.
diff --git a/unpythonic/syntax/test/test_letdo.py b/unpythonic/syntax/test/test_letdo.py
@@ -7,7 +7,6 @@
 # added by unpythonic).
 
 from ...syntax import macros, let, letseq, letrec, \
-                              let0, letseq0, letrec0, \
                               dlet, dletseq, dletrec, \
                               blet, bletseq, bletrec, \
                               do, do0, local
@@ -426,22 +425,39 @@ def test14():
                     result.append(lst)]]
     assert result == [[], [1]]
 
+    # haskelly syntax
+    result = let[((foo, 5),
+                  (bar, 2))
+                 in foo + bar]
+    assert result == 7
+
+    result = letseq[((foo, 100),
+                     (foo, 2*foo),
+                     (foo, 4*foo))
+                    in foo]
+    assert result == 800
+
+    result = letrec[((evenp, lambda x: (x == 0) or oddp(x - 1)),
+                     (oddp,  lambda x: (x != 0) and evenp(x - 1)))
+                    in [print("hi from letrec-in"),
+                        evenp(42)]]
+
     # inverted let, for situations where a body-first style improves readability:
-    result = let0[foo + bar,
+    result = let[foo + bar,
                where((foo, 5),
                      (bar, 2))]
     assert result == 7
 
-    result = letseq0[foo,
+    result = letseq[foo,
                   where((foo, 100),
                         (foo, 2*foo),
                         (foo, 4*foo))]
     assert result == 800
 
     # can also use the extra bracket syntax to get an implicit do
     # (note the [] should then enclose the body only).
-    result = letrec0[[print("hi from letrec0"),
-                      evenp(42)],
+    result = letrec[[print("hi from letrec-where"),
+                     evenp(42)],
                    where((evenp, lambda x: (x == 0) or oddp(x - 1)),
                          (oddp,  lambda x: (x != 0) and evenp(x - 1)))]
     assert result is True
diff --git a/unpythonic/syntax/util.py b/unpythonic/syntax/util.py
