enh: add autoref block macro, 'with autoref(obj)' allows writing just 'x' instead of 'obj.x' for any name in Load context

Technologicat · Technologicat · commit b43d6b099d1f · 2019-03-08T09:53:29.000+02:00
diff --git a/macro_extras/README.md b/macro_extras/README.md
@@ -56,6 +56,7 @@ Of the `python3` command-line options, the `macropy3` bootstrapper supports only
  - [**Convenience features**](#convenience-features)
    - [``cond``: the missing ``elif`` for ``a if p else b``](#cond-the-missing-elif-for-a-if-p-else-b)
    - [``aif``: anaphoric if](#aif-anaphoric-if), the test result is ``it``
+   - [``autoref``: implicitly reference attributes of an object](#autoref-implicitly-reference-attributes-of-an-object)
    - *Changed in v0.13.1.* The ``fup[]`` macro is gone, and has been replaced with the ``fup`` function, with slightly changed syntax to accommodate.
 
  - [**Other**](#other)
@@ -1484,6 +1485,26 @@ aif[[pre, ..., test],
 To denote a single expression that is a literal list, use an extra set of brackets: ``[[1, 2, 3]]``.
 
 
+### ``autoref``: implicitly reference attributes of an object
+
+*Added in v0.14.0.*
+
+Ever wished you could ``with(obj)`` to write ``x`` instead of ``obj.x`` to read attributes of an object? Enter the ``autoref`` block macro:
+
+```python
+from unpythonic.syntax import macros, autoref
+from unpythonic import env
+
+e = env(a=1, b=2)
+c = 3
+with autoref(e):
+    assert a == 1  # a --> e.a
+    assert b == 2  # b --> e.b
+    assert c == 3  # no c in e, so just c
+```
+
+The transformation is ``x --> o.x if hasattr(o, "x") else x``, applied at each use site. It is applied for names in ``Load`` context only. ``Store`` and ``Del`` are not redirected. This can be convenient e.g. with the ``.mat`` file loader of SciPy.
+
 
 ## Other
 
@@ -1496,7 +1517,7 @@ Stuff that didn't fit elsewhere.
 Mix regular code with math-notebook-like code in a ``.py`` file. To enable notebook mode, ``with nb``:
 
 ```python
-from unpythonic.syntax import nb
+from unpythonic.syntax import macros, nb
 from sympy import symbols, pprint
 
 with nb:
diff --git a/unpythonic/syntax/__init__.py b/unpythonic/syntax/__init__.py
@@ -10,6 +10,7 @@
 
 # insist, deny, it, f, _, force, force1, local, delete, block, expr, call_cc
 # are just for passing through to the client code that imports us.
+from .autoref import autoref as _autoref
 from .curry import curry as _curry
 from .forall import forall as _forall, insist, deny
 from .ifexprs import aif as _aif, it, cond as _cond
@@ -50,6 +51,33 @@ def nogensym(*args, **kwargs):
 
 # -----------------------------------------------------------------------------
 
+@macros.block
+def autoref(tree, args, *, gen_sym, **kw):
+    """Implicitly reference attributes of an object.
+
+    Example::
+
+        e = env(a=1, b=2)
+        c = 3
+        with autoref(e):
+            a
+            b
+            c
+
+    The transformation is::
+
+      x --> o.x if hasattr(o, "x") else x
+
+    The transformation is applied in ``Load`` context only. ``Store`` and ``Del``
+    are not redirected.
+
+    Useful e.g. with the ``.mat`` file loader of SciPy.
+    """
+    with dyn.let(gen_sym=gen_sym):
+        return _autoref(block_body=tree, args=args)
+
+# -----------------------------------------------------------------------------
+
 @macros.expr
 def aif(tree, *, gen_sym, **kw):
     """[syntax, expr] Anaphoric if.
diff --git a/unpythonic/syntax/autoref.py b/unpythonic/syntax/autoref.py
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+"""Implicitly reference attributes of an object."""
+
+from ast import Name, Assign, Attribute, Load
+
+from macropy.core.quotes import macros, q, u, name, ast_literal
+from macropy.core.walkers import Walker
+
+from ..dynassign import dyn
+
+def autoref(block_body, args):
+    assert len(args) == 1, "expected exactly one argument, the object to implicitly reference"
+    assert block_body, "expected at least one statement in the 'with autoref' block"
+
+    # assign the implicit object to a temporary name, to resolve a computed reference only once
+    gen_sym = dyn.gen_sym
+    ref = gen_sym("r")
+
+    @Walker
+    def transform(tree, *, stop, **kw):
+        if not (type(tree) is Name and type(tree.ctx) is Load):
+            return tree
+        stop()
+        x = tree.id
+        theattr = Attribute(value=q[name[ref]], attr=x)
+        newtree = q[ast_literal[theattr] if hasattr(name[ref], u[x]) else ast_literal[tree]]
+        return newtree
+
+    newbody = [Assign(targets=[q[name[ref]]], value=args[0])]
+    for stmt in block_body:
+        newbody.append(transform.recurse(stmt))
+
+    return newbody
diff --git a/unpythonic/syntax/test/test_autoref.py b/unpythonic/syntax/test/test_autoref.py
@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+"""Implicitly reference attributes of an object."""
+
+from ...syntax import macros, autoref
+
+from ...env import env
+
+def test():
+    e = env(a=1, b=2)
+    c = 3
+    with autoref(e):
+        assert a == 1  # a --> e.a
+        assert b == 2  # b --> e.b
+        assert c == 3  # no c in e, so just c
+
+    print("All tests PASSED")
+
+if __name__ == '__main__':
+    test()
