add rackety let_syntax

Technologicat · Technologicat · commit 2de12fd279be · 2018-11-04T12:43:37.000+02:00
diff --git a/macro_extras/main.py b/macro_extras/main.py
@@ -13,6 +13,7 @@
                               let, letseq, letrec, \
                               dlet, dletseq, dletrec, \
                               blet, bletseq, bletrec, \
+                              let_syntax, \
                               do, do0, local, \
                               forall, insist, deny, \
                               aif, it, \
@@ -417,6 +418,23 @@ def test14():
                     result.append(lst)]]
     assert result == [[], [1]]
 
+    # local **syntactic** bindings (code splicing at macro-expansion time)
+    evaluations = 0
+    def verylongfunctionname(x=1):
+        nonlocal evaluations
+        evaluations += 1
+        return x
+    y = let_syntax((f, verylongfunctionname))[[  # extra brackets: implicit do
+                     f(),
+                     f(5)]]
+    assert evaluations == 2
+    assert y == 5
+    y = let_syntax((f(a), verylongfunctionname(2*a)))[[  # templating
+                     f(2),
+                     f(3)]]
+    assert evaluations == 4
+    assert y == 6
+
     # multilambda: multi-expression lambdas with implicit do
     with multilambda:
         # use brackets around the body of a lambda to denote a multi-expr body
diff --git a/unpythonic/syntax/__init__.py b/unpythonic/syntax/__init__.py
@@ -19,6 +19,7 @@
                                     let as _let, letseq as _letseq, letrec as _letrec, \
                                     dlet as _dlet, dletseq as _dletseq, dletrec as _dletrec, \
                                     blet as _blet, bletseq as _bletseq, bletrec as _bletrec
+from unpythonic.syntax.letsyntax import let_syntax_expr
 from unpythonic.syntax.prefix import prefix as _prefix
 from unpythonic.syntax.tailtools import autoreturn as _autoreturn, tco as _tco, \
                                         continuations as _continuations, bind
@@ -477,6 +478,61 @@ def do0(tree, gen_sym, **kw):
 
 # -----------------------------------------------------------------------------
 
+@macros.expr
+def let_syntax(tree, args, gen_sym, **kw):
+    """Introduce local **syntactic** bindings.
+
+    Usage::
+
+        let_syntax((lhs, rhs), ...)[body]
+
+        let_syntax((lhs, rhs), ...)[[body0, ...]]
+
+    The bindings are applied **at macro expansion time**, substituting
+    the expression on the RHS for each instance of the corresponding LHS.
+    This macro runs in the first pass (outside in).
+
+    This is useful to e.g. locally abbreviate long macro names,
+    or to splice in several (parametric) instances of a common pattern.
+
+    The 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 body, a template is used like a function call. Just like in an
+          actual function call, when the template is substituted, the formal
+          parameters on its RHS get replaced by the argument values from the
+          "call" site; but ``let_syntax`` performs this at macro-expansion time.
+
+    This is a two-step process. In the first step, we apply template substitutions.
+    In the second step, we apply bare name substitutions to the result of the
+    first step. (So RHSs of templates may use any of the bare-name definitions.)
+
+    Within each step, the substitutions are applied **in the order specified**.
+    So if the bindings are ``((x, y), (y, z))``, then ``x`` transforms to ``z``.
+    But if the bindings are ``((y, z), (x, y))``, then ``x`` transforms to ``y``,
+    and only an explicit ``y`` at the use site transforms to ``z``.
+
+    Inspired by Racket's ``let-syntax``, see:
+        https://docs.racket-lang.org/reference/let.html
+
+    **CAUTION**: This is essentially a toy macro system inside a macro system.
+    The usual caveats of macro systems apply. Especially, we support absolutely
+    no form of hygiene. Be very, very careful to avoid name conflicts.
+
+    ``let_syntax`` is meant only for simple local substitutions. If you need to
+    do something complex, prefer writing a real macro directly in MacroPy.
+    """
+    with dyn.let(gen_sym=gen_sym):  # gen_sym is only needed by the implicit do.
+        return (yield from let_syntax_expr(bindings=args, body=tree))
+
+# -----------------------------------------------------------------------------
+
 @macros.expr
 def forall(tree, **kw):
     """[syntax, expr] Nondeterministic evaluation.
diff --git a/unpythonic/syntax/letsyntax.py b/unpythonic/syntax/letsyntax.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# This is for introducing **syntactic** local bindings, i.e. simple code splicing
+# at macro expansion time. If you're looking for regular run-time let et al. macros,
+# see letdo.py.
+
+from ast import Name, Call, Starred
+from copy import deepcopy
+
+from macropy.core.walkers import Walker
+
+from unpythonic.syntax.letdo import implicit_do
+
+def let_syntax_expr(bindings, body):
+    body = implicit_do(body)  # support the extra bracket syntax
+    if not bindings:
+        return body
+    templates, barenames = _split_bindings(bindings)
+    def substitute_barename(name, value, tree):
+        @Walker
+        def splice(tree, **kw):
+            if type(tree) is Name and tree.id == name:
+                tree = value
+            return tree
+        return splice.recurse(tree)
+    for name, formalparams, value in templates:
+        @Walker
+        def splice(tree, **kw):
+            if type(tree) is Call and type(tree.func) is Name and tree.func.id == name:
+                theargs = tree.args
+                if len(theargs) != len(formalparams):
+                    assert False, "let_syntax template '{}' expected {} arguments, got {}".format(name,
+                                                                                                  len(formalparams),
+                                                                                                  len(theargs))
+                # 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
+                    tree = substitute_barename(k, v, tree)
+            return tree
+        body = splice.recurse(body)
+    for name, _, value in barenames:
+        body = substitute_barename(name, value, body)
+    yield body  # first-pass macro (outside in) so that we can e.g. let_syntax((a, ast_literal))[...]
+
+# TODO: implement a block version; should probably support some form of "with" to allow substituting statements.
+#def let_syntax_block(bindings, block_body):
+#    pass
+
+# -----------------------------------------------------------------------------
+
+def _split_bindings(bindings):  # bindings: sequence of ast.Tuple: (k1, v1), (k2, v2), ..., (kn, vn)
+    names = set()
+    templates = []
+    barenames = []
+    for line in bindings:
+        k, v = line.elts
+        if type(k) is Name:
+            name = k.id
+            args = []
+        elif type(k) is Call and type(k.func) is Name:  # simple templating f(x, ...)
+            name = k.func.id
+            if any(type(a) is Starred for a in k.args):  # *args (Python 3.5+)
+                assert False, "in template, only positional slots supported (no *args)"
+            args = [a.id for a in k.args]
+            if k.keywords:
+                assert False, "in template, only positional slots supported (no named args or **kwargs)"
+        else:
+            assert False, "expected a name (e.g. x) or a template (e.g. f(x, ...)) on the LHS"
+        if name in names:
+            assert False, "duplicate '{}'; names defined in the same let_syntax must be unique".format(name)
+        names.add(name)
+        target = templates if args else barenames
+        target.append((name, args, v))
+    return templates, barenames
