parametric blocks in let_syntax

Technologicat · Technologicat · commit a8c8f80f8c77 · 2018-11-05T15:30:32.000+02:00
diff --git a/macro_extras/main.py b/macro_extras/main.py
@@ -475,6 +475,15 @@ def verylongfunctionname(x=1):
         assert lst == [4, 5, 6]
         assert snd == 5
 
+        with block(a, b, c) as makeabc:
+            lst = [a, b, c]
+        makeabc(3 + 4, 2**3, 3 * 3)
+        assert lst == [7, 8, 9]
+        with expr(n) as nth:
+            lst[n]
+        assert nth(2) == 9
+        # TODO: add more tests
+
     # nesting: each "with let_syntax" is a lexical scope for syntactic substitutions
     with let_syntax:
         with block as makelst:
diff --git a/unpythonic/syntax/__init__.py b/unpythonic/syntax/__init__.py
@@ -502,13 +502,19 @@ def let_syntax(tree, **kw):
     Usage - block variant::
 
         with let_syntax:
-            with block as xs:  # capture a block of statements
+            with block as xs:          # capture a block of statements - bare name
+                ...
+            with block(a, ...) as xs:  # capture a block of statements - template
+                ...
+            with expr as x:            # capture a single expression - bare name
+                ...
+            with expr(a, ...) as x:    # capture a single expression - template
                 ...
-            with expr as x:    # capture a single expression
-                ...            # (can explicitly use do[] here if necessary)
             body0
             ...
 
+    A single expression can be a ``do[]`` if multiple expressions are needed.
+
     The bindings are applied **at macro expansion time**, substituting
     the expression on the RHS for each instance of the corresponding LHS.
     Each substitution gets a fresh copy.
@@ -517,28 +523,33 @@ def let_syntax(tree, **kw):
     expansion time (with zero run-time overhead), or to splice in several
     (possibly parametric) instances of a common pattern.
 
-    The LHS may be:
+    In the expression variant, ``lhs`` may be:
 
       - A bare name (e.g. ``x``), or
 
       - A simple template of the form ``f(x, ...)``. The names inside the
         parentheses declare the formal parameters of the template.
 
-        Templates support only positional arguments, with no default values.
+    In the block variant:
+
+      - The name of the LHS goes in the **as-part**.
+
+      - If a template, the formal parameters are declared on the ``block``
+        or ``expr``. Parameters are always expressions (because they use the
+        function-call syntax).
+
+    **Templates**
 
-        In the body, a template is used like a function call. Just like in an
-        actual function call, when the template is substituted, any instances
-        of its formal parameters on its RHS get replaced by the argument values
-        from the "call" site; but ``let_syntax`` performs this at macro-expansion
-        time. Note each instance of the same formal parameter gets a fresh copy
-        of the corresponding argument value.
+    To make parametric substitutions, use templates.
 
-    In the block variant, the **as-part** is the LHS, and the body of the
-    ``with block as ...`` or ``with expr as ...`` block is the RHS.
+    Templates support only positional arguments, with no default values.
 
-    **CAUTION**: In a block-variant template, all formal parameters are also
-    handled in block mode, as statements. (This is subject to change in a
-    future version.)
+    In the body, a template is used like a function call. Just like in an
+    actual function call, when the template is substituted, any instances
+    of its formal parameters on its RHS get replaced by the argument values
+    from the "call" site; but ``let_syntax`` performs this at macro-expansion
+    time. Note each instance of the same formal parameter gets a fresh copy
+    of the corresponding argument value.
 
     **Substitution order**
 
@@ -576,6 +587,7 @@ def abbrev(tree, args, gen_sym, **kw):
     with dyn.let(gen_sym=gen_sym):  # gen_sym is only needed by the implicit do.
         yield let_syntax_expr(bindings=args, body=tree)
 
+# TODO: abbrev does nest, but not in the lexical-scoping way. Update explanation!
 @macros.block
 def abbrev(tree, **kw):
     """Exactly like ``let_syntax``, but expands in the first pass, outside in.
diff --git a/unpythonic/syntax/letsyntax.py b/unpythonic/syntax/letsyntax.py
@@ -6,11 +6,10 @@
 
 from functools import partial
 from copy import deepcopy
-from ast import Name, Call, Starred, If, Num, Expr
+from ast import Name, Call, Starred, If, Num, Expr, With
 
 from macropy.core.walkers import Walker
 
-from unpythonic.syntax.util import isnamedwith
 from unpythonic.syntax.letdo import implicit_do
 
 def let_syntax_expr(bindings, body):  # bindings: sequence of ast.Tuple: (k1, v1), (k2, v2), ..., (kn, vn)
@@ -38,30 +37,43 @@ def register_bindings():
 
 # -----------------------------------------------------------------------------
 
-# TODO: parametric block, expr (currently doesn't work, assignment to something
-# TODO: that looks like a function call is syntactically invalid in Python)
-
 # block version:
 #
 # with let_syntax:
-#     with block as xs:  # capture a block of statements
+#     with block as xs:
+#         ...
+#     with block(a, ...) as xs:
+#         ...
+#     with expr as x:
+#         ...
+#     with expr(a, ...) as x:
 #         ...
-#     with expr as x:    # capture a single expression
-#         ...            # can explicitly use do[] here if necessary
 #     body0
 #     ...
 #
 def let_syntax_block(block_body):
     names_seen = set()
     templates = []
     barenames = []
-    def register_binding(withstmt, mode):  # "with block:" or "with expr:"
+    def register_binding(withstmt, mode, kind):
+        assert mode in ("block", "expr")
+        assert kind in ("barename", "template")
+        ctxmanager = withstmt.items[0].context_expr
         optvars = withstmt.items[0].optional_vars
         if not optvars:
-            assert False, "'with {}:': expected a name (e.g. x) or a template (e.g. f(x, ...)) as the as-part".format(mode)
-        name, args = _analyze_lhs(optvars)
+            assert False, "'with {}:': expected an as-part".format(mode)
+        if type(optvars) is not Name:
+            assert False, "'with {}:': expected exactly one name in the as-part".format(mode)
+
+        name = optvars.id
         if name in names_seen:
             assert False, "duplicate '{}'; as-parts in the same let_syntax block must be unique".format(name)
+
+        if kind == "template":
+            _, args = _analyze_lhs(ctxmanager)  # syntactic limitation, can't place formal parameter list on the as-part
+        else: # kind == "barename":
+            args = []
+
         if mode == "block":
             value = If(test=Num(n=1),
                        body=withstmt.body,
@@ -72,20 +84,28 @@ def register_binding(withstmt, mode):  # "with block:" or "with expr:"
                 assert False, "'with expr:' expected a one-item body (use a do[] if need more)"
             theexpr = withstmt.body[0]
             if type(theexpr) is not Expr:
-                assert False, "'with expr:' expected an expression in body, got a statement"
+                assert False, "'with expr:' expected an expression body, got a statement"
             value = theexpr.value  # discard Expr wrapper in definition
         names_seen.add(name)
         target = templates if args else barenames
         target.append((name, args, value, mode))
 
-    iswithblock = partial(isnamedwith, name="block")  # "with block as ...:"
-    iswithexpr = partial(isnamedwith, name="expr")    # "with expr as ...:"
+    def isbinding(tree):
+        for mode in ("block", "expr"):
+            if not (type(tree) is With and len(tree.items) == 1):
+                continue
+            ctxmanager = tree.items[0].context_expr
+            if type(ctxmanager) is Name and ctxmanager.id == mode:
+                return mode, "barename"
+            if type(ctxmanager) is Call and type(ctxmanager.func) is Name and ctxmanager.func.id == mode:
+                return mode, "template"
+        return False
+
     new_block_body = []
     for stmt in block_body:
-        if iswithblock(stmt):
-            register_binding(stmt, "block")
-        elif iswithexpr(stmt):
-            register_binding(stmt, "expr")
+        binding_data = isbinding(stmt)
+        if binding_data:
+            register_binding(stmt, *binding_data)
         else:
             stmt = _substitute_templates(templates, stmt)
             stmt = _substitute_barenames(barenames, stmt)
@@ -161,9 +181,8 @@ def splice(tree, *, stop, **kw):
                 # make a fresh deep copy of the RHS to avoid destroying the template.
                 tree = deepcopy(value)  # expand the f itself in f(x, ...)
                 for k, v in zip(formalparams, theargs):  # expand the x, ... in the expanded form of f
-                    # TODO: Currently all args of a block substitution are handled in block mode (as statements).
-                    # TODO: Some configurability may be needed here.
-                    tree = _substitute_barename(k, v, tree, mode)
+                    # can't put statements in a Call, so always treat args as expressions.
+                    tree = _substitute_barename(k, v, tree, "expr")
             return tree
         tree = splice.recurse(tree)
     return tree
diff --git a/unpythonic/syntax/util.py b/unpythonic/syntax/util.py
@@ -33,17 +33,6 @@ def isx(tree, x, accept_attr=True):
            (type(tree) is Captured and tree.name == x) or \
            (accept_attr and type(tree) is Attribute and tree.attr == x)
 
-def isnamedwith(tree, name):
-    """Test whether tree is ``with name:``.
-
-    Only a simple with-block with only one context manager with a bare name
-    is supported.
-    """
-    if not (type(tree) is With and len(tree.items) == 1):
-        return False
-    ctxmanager = tree.items[0].context_expr
-    return type(ctxmanager) is Name and ctxmanager.id == name
-
 def islet(tree, expanded=True):
     """Test whether tree is a ``let[]``, ``letseq[]`` or ``letrec[]``.
 
