Technologicat
diff --git a/‎unpythonic/syntax/__init__.py‎
Lines changed: 9 additions & 1 deletion b/‎unpythonic/syntax/__init__.py‎
Lines changed: 9 additions & 1 deletion
diff --git a/‎unpythonic/syntax/nb.py‎
Lines changed: 54 additions & 0 deletions b/‎unpythonic/syntax/nb.py‎
Lines changed: 54 additions & 0 deletions
diff --git a/‎unpythonic/syntax/test/test_nb.py‎
Lines changed: 20 additions & 1 deletion b/‎unpythonic/syntax/test/test_nb.py‎
Lines changed: 20 additions & 1 deletion
@@ -25,7 +25,7 @@
                    blet as _blet, bletseq as _bletseq, bletrec as _bletrec
 from .letsyntax import let_syntax_expr, let_syntax_block, block, expr
 from .nb import nb as _nb, dbg_block as _dbg_block, dbg_expr as _dbg_expr, \
-                           dbgprint_block, dbgprint_expr
+                           dbgprint_block, dbgprint_expr, pop_while as _pop_while
 from .prefix import prefix as _prefix
 from .tailtools import autoreturn as _autoreturn, tco as _tco, \
                        continuations as _continuations, call_cc
@@ -1516,6 +1516,14 @@ def dbg(tree, args, **kw):
 
 # -----------------------------------------------------------------------------
 
+@macros.block
+def pop_while(tree, args, *, gen_sym, **kw):
+    """TODO: document""" # TODO: document
+    with dyn.let(gen_sym=gen_sym):
+        return _pop_while(body=tree, args=args)
+
+# -----------------------------------------------------------------------------
+
 @macros.block
 def lazify(tree, *, gen_sym, **kw):
     """[syntax, block] Call-by-need for Python.
 
@@ -16,6 +16,8 @@
 from macropy.core.walkers import Walker
 from macropy.core import unparse
 
+from ..dynassign import dyn
+
 def nb(body, args):
     p = args[0] if args else q[print]  # custom print function hook
     newbody = []
@@ -36,6 +38,8 @@ def nb(body, args):
 
 # -----------------------------------------------------------------------------
 
+# TODO: refactor dbg into its own module
+
 def dbgprint_block(ks, vs, *, filename=None, lineno=None, sep=", ", **kwargs):
     """Default debug printer for the ``dbg`` macro, block variant.
 
@@ -154,3 +158,53 @@ def dbgprint_expr(k, v, *, filename, lineno):
 def dbg_expr(tree):
     ln = q[u[tree.lineno]] if hasattr(tree, "lineno") else q[None]
     return q[dbgprint_expr(u[unparse(tree)], ast_literal[tree], filename=__file__, lineno=ast_literal[ln])]
+
+# -----------------------------------------------------------------------------
+
+# TODO: refactor pop_while into its own module
+
+# Imperative list handling tool::
+#
+#     with pop_while(name, expr):
+#         ...
+#
+#     with pop_while(expr):
+#         ...
+#
+# transforms into::
+#
+#     name = expr   # or (gensym) = expr in the 1-arg form
+#     while name:
+#         it = name.pop(0)  # "it" is literal, visible in user code
+#         ...
+#
+# The point is the user code may append to or extend the list ``name``;
+# this simplifies writing some algorithms.
+#
+def pop_while(body, args):
+    gen_sym = dyn.gen_sym
+    if len(args) == 1:
+        theinput = args[0]
+        thename = gen_sym("_tmp")
+    elif len(args) == 2:
+        theinput = args[1]
+        thename = args[0]
+        if type(thename) is not Name:
+            assert False, "in the two-argument form, the first argument must be a bare name"
+        thename = thename.id
+    else:
+        assert False, "pop_while takes exactly one or two arguments"
+
+    with q as newbody:
+        __the_tmp = ast_literal[theinput]
+        while __the_tmp:
+            it = __the_tmp.pop(0)
+    thewhile = newbody[-1]
+    thewhile.body.extend(body)
+
+    @Walker
+    def renametmp(tree, **kw):
+        if type(tree) is Name and tree.id == "__the_tmp":
+            tree.id = thename
+        return tree
+    return renametmp.recurse(newbody)
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-from ...syntax import macros, nb, dbg
+from ...syntax import macros, nb, dbg, pop_while
 from ...misc import call
 
 def test():
@@ -65,6 +65,25 @@ def just_a_scope():
         x = dbg[2 + 3]
         assert x == ("(2 + 3)", 5)
 
+    # silly imperative pop-while construct for handling lists in cases
+    # where the body needs to append to or extend the input (so that a
+    # for-loop is not appropriate)
+    lst1 = list(range(5))
+    lst2 = []
+    with pop_while(lst1):
+        lst2.append(it)
+    assert lst1 == []
+    assert lst2 == list(range(5))
+
+    lst1 = list(range(5))
+    lst2 = []
+    with pop_while(mylist, lst1):  # pop_while(name_as, expr)
+        lst2.append(it)
+        if it == 4:
+            mylist.append(5)
+    assert lst1 == []
+    assert lst2 == list(range(6))
+
     print("All tests PASSED")
 
 if __name__ == '__main__':