curry: by default, TypeError if args remaining when exiting top-level curry context; enh: accept just tuple as the pythonic multiple-return-values thing (not liśt); greppability: always use ordering (list, tuple) in cases where both are ok

Technologicat · Technologicat · commit 4c7cc601e557 · 2018-09-25T00:16:49.000+03:00
diff --git a/README.md b/README.md
@@ -223,9 +223,9 @@ p | runpipe
 assert fibos == [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
 ```
 
-Both one-in-one-out (*1-to-1*) and n-in-m-out (*n-to-m*) pipes are provided. The 1-to-1 versions have names suffixed with ``1``. The use case is one-argument functions that return one value (which may also be a tuple or list).
+Both one-in-one-out (*1-to-1*) and n-in-m-out (*n-to-m*) pipes are provided. The 1-to-1 versions have names suffixed with ``1``. The use case is one-argument functions that return one value (which may also be a tuple).
 
-In the n-to-m versions, when a function returns a tuple or list, it is unpacked to the argument list of the next function in the pipe. At ``getvalue`` or ``runpipe`` time, the tuple wrapper (if any) around the final result is discarded if it contains only one item. (This allows the n-to-m versions to work also with a single value, as long as it is not a tuple or list.) The main use case is computations that deal with multiple values, the number of which may also change during the computation (as long as there are as many "slots" on both sides of each individual connection).
+In the n-to-m versions, when a function returns a tuple, it is unpacked to the argument list of the next function in the pipe. At ``getvalue`` or ``runpipe`` time, the tuple wrapper (if any) around the final result is discarded if it contains only one item. (This allows the n-to-m versions to work also with a single value, as long as it is not a tuple.) The main use case is computations that deal with multiple values, the number of which may also change during the computation (as long as there are as many "slots" on both sides of each individual connection).
 
 
 ### Introduce local bindings: ``let``, ``letrec``
@@ -1096,9 +1096,9 @@ Some overlap with [toolz](https://github.com/pytoolz/toolz) and [funcy](https://
      - As a regular function, `curry` itself is curried à la Racket. If it gets extra arguments (beside the function ``f``), they are the first step. This helps eliminate many parentheses.
    - **Caution**: If the positional arities of ``f`` cannot be inspected, currying fails, raising ``UnknownArity``. This may happen with builtins such as ``operator.add``.
  - `composel`, `composer`: both left-to-right and right-to-left function composition, to help readability.
-   - Any number of positional arguments is supported, with the same rules as in the pipe system. Multiple return values packed into a tuple or list are unpacked to the argument list of the next function in the chain.
+   - Any number of positional arguments is supported, with the same rules as in the pipe system. Multiple return values packed into a tuple are unpacked to the argument list of the next function in the chain.
    - `composelc`, `composerc`: curry each function before composing them. Useful with passthrough.
-   - `composel1`, `composer1`: 1-in-1-out chains (faster; also useful for a single value that is a tuple or list).
+   - `composel1`, `composer1`: 1-in-1-out chains (faster; also useful for a single value that is a tuple).
    - suffix `i` to use with an iterable (`composeli`, `composeri`, `composelci`, `composerci`, `composel1i`, `composer1i`)
  - `andf`, `orf`, `notf`: compose predicates (like Racket's `conjoin`, `disjoin`, `negate`).
  - `rotate`: a cousin of `flip`, for permuting positional arguments.
@@ -1450,7 +1450,7 @@ assert tuple(uniq((1, 1, 2, 2, 2, 1, 2, 2, 4, 3, 4, 3, 3))) == (1, 2, 1, 2, 4, 3
 assert tuple(flatten1(((1, 2), (3, (4, 5), 6), (7, 8, 9)))) == (1, 2, 3, (4, 5), 6, 7, 8, 9)
 assert tuple(flatten(((1, 2), (3, (4, 5), 6), (7, 8, 9)))) == (1, 2, 3, 4, 5, 6, 7, 8, 9)
 
-is_nested = lambda sublist: all(isinstance(x, (tuple, list)) for x in sublist)
+is_nested = lambda sublist: all(isinstance(x, (list, tuple)) for x in sublist)
 assert tuple(flatten((((1, 2), (3, 4)), (5, 6)), is_nested)) == ((1, 2), (3, 4), (5, 6))
 
 data = (((1, 2), ((3, 4), (5, 6)), 7), ((8, 9), (10, 11)))
diff --git a/unpythonic/ec.py b/unpythonic/ec.py
@@ -152,7 +152,7 @@ def s(loop, acc=0, i=0):
         assert f() == 15
     """
     if tags is not None:
-        if isinstance(tags, (tuple, list)):  # multiple tags
+        if isinstance(tags, tuple):  # multiple tags
             tags = set(tags)
         else: # single tag
             tags = set((tags,))
diff --git a/unpythonic/fold.py b/unpythonic/fold.py
@@ -393,12 +393,19 @@ def mymap_one2(f, iterable):
     assert doubler(ll(1, 2, 3)) == ll(2, 4, 6)
 
     # curry supports passing through on the right any args over the max arity.
-    assert curry(double, 2, "foo") == (4, "foo")   # arity of double is 1
-
-    # In passthrough, if an intermediate result is a callable,
-    # it is invoked on the remaining positional args:
+    # If an intermediate result is a callable, it is invoked on the remaining
+    # positional args:
     assert curry(mymap_one4, double, ll(1, 2, 3)) == ll(2, 4, 6)
 
+    # But having any args remaining when the top-level curry context exits
+    # is an error:
+    try:
+        curry(double, 2, "foo")
+    except TypeError:
+        pass
+    else:
+        assert False   # top-level curry context exited with args remaining
+
     # This also works; curried f takes one argument and the second one is passed
     # through on the right; this two-tuple then ends up as the arguments to cons.
     mymap_one5 = lambda f: curry(foldr, composer(cons, curry(f)), nil)
diff --git a/unpythonic/fun.py b/unpythonic/fun.py
@@ -21,6 +21,7 @@
 
 from unpythonic.arity import arities
 from unpythonic.fold import reducel
+from unpythonic.dynscope import dyn, make_dynvar
 
 def memoize(f):
     """Decorator: memoize the function f.
@@ -61,6 +62,8 @@ def memoized(*args, **kwargs):
 #        return memo[k]
 #    return memoized
 
+make_dynvar(_curry_context=None)
+make_dynvar(curry_toplevel_passthrough=False)
 def curry(f, *args, **kwargs):
     """Decorator: curry the function f.
 
@@ -100,13 +103,9 @@ def foo(a, b, *, c, d):
 
     **Passthrough**:
 
-    If too many args are given, any extra ones are passed through on the right::
-
-        double = lambda x: 2 * x
-        assert curry(double)(2, "foo") == (4, "foo")
-
-    In passthrough, if an intermediate result is callable it is invoked
-    on the remaining positional args::
+    If too many args are given, any extra ones are passed through on the right.
+    If an intermediate result is callable, it is invoked on the remaining
+    positional args::
 
         map_one = lambda f: (curry(foldr))(composer(cons, to1st(f)), nil)
         assert curry(map_one)(double, ll(1, 2, 3)) == ll(2, 4, 6)
@@ -118,6 +117,19 @@ def foo(a, b, *, c, d):
     For simplicity, in passthrough, all kwargs are consumed in the first step
     for which too many positional args were supplied.
 
+    By default, if any passed-through positional args are still remaining when
+    the currently top-level curry context exits, ``curry`` raises ``TypeError``,
+    because such usage often indicates a bug.
+
+    This behavior can be locally modified by setting the dynvar
+    ``curry_toplevel_passthrough``::
+
+        with dyn.let(curry_toplevel_passthrough=True):
+            curry(double, 2, "foo") == (4, "foo")
+
+    Because it is a dynvar, it affects all ``curry`` calls in its dynamic extent,
+    including ones inside library functions such as ``composerc`` or ``pipec``.
+
     **Curry itself is curried**:
 
     When invoked as a regular function (not decorator), curry itself is curried.
@@ -128,8 +140,6 @@ def foo(a, b, *, c, d):
 
     This comboes with passthrough::
 
-        assert curry(double, 2, "foo") == (4, "foo")
-
         mymap = lambda f: curry(foldr, composerc(cons, f), nil)
         add = lambda x, y: x + y
         assert curry(mymap, add, ll(1, 2, 3), ll(4, 5, 6)) == ll(5, 7, 9)
@@ -151,22 +161,28 @@ def foo(a, b, *, c, d):
     min_arity, max_arity = arities(f)
     @wraps(f)
     def curried(*args, **kwargs):
-        if len(args) < min_arity:
-            return curry(partial(f, *args, **kwargs))
-        # passthrough on right, like https://github.com/Technologicat/spicy
-        if len(args) > max_arity:
-            now_args, later_args = args[:max_arity], args[max_arity:]
-            now_result = f(*now_args, **kwargs)  # use up all kwargs now
-            if callable(now_result):
-                # curry it now, to sustain the chain in case we have
-                # too many (or too few) args for it.
-                if not iscurried(now_result):
-                    now_result = curry(now_result)
-                return now_result(*later_args)
-            if isinstance(now_result, (tuple, list)):
-                return tuple(now_result) + later_args
-            return (now_result,) + later_args
-        return f(*args, **kwargs)
+        outerctx = dyn._curry_context
+        with dyn.let(_curry_context=(outerctx, f)):
+            if len(args) < min_arity:
+                return curry(partial(f, *args, **kwargs))
+            # passthrough on right, like https://github.com/Technologicat/spicy
+            if len(args) > max_arity:
+                now_args, later_args = args[:max_arity], args[max_arity:]
+                now_result = f(*now_args, **kwargs)  # use up all kwargs now
+                if callable(now_result):
+                    # curry it now, to sustain the chain in case we have
+                    # too many (or too few) args for it.
+                    if not iscurried(now_result):
+                        now_result = curry(now_result)
+                    return now_result(*later_args)
+                if not (outerctx or dyn.curry_toplevel_passthrough):
+                    raise TypeError("Top-level curry context exited with {:d} arg(s) remaining: {}".format(len(later_args), later_args))
+                # pass through to the curried procedure waiting in outerctx
+                # (e.g. in a curried compose chain)
+                if isinstance(now_result, tuple):
+                    return now_result + later_args
+                return (now_result,) + later_args
+            return f(*args, **kwargs)
     curried._is_curried_function = True  # stash for detection
     # curry itself is curried: if we get args, they're the first step
     if args or kwargs:
@@ -387,10 +403,18 @@ def composel1i(iterable):
 def _make_compose(direction):  # "left", "right"
     def compose_two(f, g):
         def composed(*args):
-            a = g(*args)
-            # we could duck-test but this is more predictable for the user
-            # (consider chaining functions that manipulate a generator).
-            if isinstance(a, (list, tuple)):
+            # co-operate with curry: provide a top-level curry context
+            # to allow passthrough from the function that is applied first
+            # to the function that is applied second.
+            if iscurried(f):
+                with dyn.let(_curry_context=(dyn._curry_context, composed)):
+                    a = g(*args)
+            else:
+                a = g(*args)
+            # we could duck-test, but this is more predictable for the user
+            # (consider chaining functions that manipulate a generator), and
+            # tuple specifically is the pythonic multiple-return-values thing.
+            if isinstance(a, tuple):
                 return f(*a)
             return f(a)
         return composed
@@ -408,7 +432,7 @@ def composer(*fs):
 
     This mirrors the standard mathematical convention (f ∘ g)(x) ≡ f(g(x)).
 
-    At each step, if the output from a function is a list or a tuple,
+    At each step, if the output from a function is a tuple,
     it is unpacked to the argument list of the next function. Otherwise,
     we assume the output is intended to be fed to the next function as-is.
 
diff --git a/unpythonic/it.py b/unpythonic/it.py
@@ -449,7 +449,7 @@ def flatten(iterable, pred=None):
 
     E.g. to flatten only those items that contain only tuples::
 
-        is_nested = lambda e: all(isinstance(x, (tuple, list)) for x in e)
+        is_nested = lambda e: all(isinstance(x, (list, tuple)) for x in e)
         data = (((1, 2), (3, 4)), (5, 6))
         assert tuple(flatten(data, is_nested)) == ((1, 2), (3, 4), (5, 6))
     """
@@ -479,7 +479,7 @@ def flatten_in(iterable, pred=None):
 
     Example::
 
-        is_nested = lambda e: all(isinstance(x, (tuple, list)) for x in e)
+        is_nested = lambda e: all(isinstance(x, (list, tuple)) for x in e)
         data = (((1, 2), ((3, 4), (5, 6)), 7), ((8, 9), (10, 11)))
         assert tuple(flatten(data, is_nested))    == \\
                (((1, 2), ((3, 4), (5, 6)), 7), (8, 9), (10, 11))
@@ -636,7 +636,7 @@ def sum_and_diff(a, b):
     assert tuple(flatten(((1, 2), (3, (4, 5), 6), (7, 8, 9)))) == (1, 2, 3, 4, 5, 6, 7, 8, 9)
     assert tuple(flatten1(((1, 2), (3, (4, 5), 6), (7, 8, 9)))) == (1, 2, 3, (4, 5), 6, 7, 8, 9)
 
-    is_nested = lambda e: all(isinstance(x, (tuple, list)) for x in e)
+    is_nested = lambda e: all(isinstance(x, (list, tuple)) for x in e)
     assert tuple(flatten((((1, 2), (3, 4)), (5, 6)), is_nested)) == ((1, 2), (3, 4), (5, 6))
 
     data = (((1, 2), ((3, 4), (5, 6)), 7), ((8, 9), (10, 11)))
diff --git a/unpythonic/seq.py b/unpythonic/seq.py
@@ -11,7 +11,8 @@
 from collections import namedtuple
 from unpythonic.env import env
 from unpythonic.misc import call
-from unpythonic.fun import curry
+from unpythonic.fun import curry, iscurried
+from unpythonic.dynscope import dyn
 from unpythonic.arity import arity_includes, UnknownArity
 
 # sequence side effects in a lambda
@@ -246,7 +247,7 @@ def pipe(values0, *bodys):
     The only restriction is that each function must take as many positional
     arguments as the previous one returns.
 
-    At each step, if the output from a function is a list or a tuple,
+    At each step, if the output from a function is a tuple,
     it is unpacked to the argument list of the next function. Otherwise,
     we assume the output is intended to be fed to the next function as-is.
 
@@ -271,12 +272,24 @@ def pipe(values0, *bodys):
         assert (a, b) == (13, "got foo")
     """
     xs = values0
-    for update in bodys:
-        if isinstance(xs, (list, tuple)):
+    n = len(bodys)
+    def doit():
+        nonlocal xs
+        if isinstance(xs, tuple):
             xs = update(*xs)
         else:
             xs = update(xs)
-    if isinstance(xs, (list, tuple)):
+    for k, update in enumerate(bodys):
+        islast = (k == n - 1)
+        # co-operate with curry: provide a top-level curry context
+        # to allow passthrough from a pipelined function to the next
+        # (except the last one, since it exits the curry context).
+        if iscurried(update) and not islast:
+            with dyn.let(_curry_context=(dyn._curry_context, update)):
+                doit()
+        else:
+            doit()
+    if isinstance(xs, tuple):
         return xs if len(xs) > 1 else xs[0]
     return xs
 
@@ -311,11 +324,11 @@ def __or__(self, f):
         if f is getvalue:
             return xs if len(xs) > 1 else xs[0]
         cls = self.__class__
-        if isinstance(xs, (list, tuple)):
+        if isinstance(xs, tuple):
             newxs = f(*xs)
         else:
             newxs = f(xs)
-        if isinstance(newxs, (list, tuple)):
+        if isinstance(newxs, tuple):
             return cls(*newxs)
         return cls(newxs)
     def __repr__(self):
@@ -356,7 +369,7 @@ def __or__(self, f):
         if f is runpipe:  # compute now
             vs = self._xs
             for g in self._funcs:
-                if isinstance(vs, (list, tuple)):
+                if isinstance(vs, tuple):
                     vs = g(*vs)
                 else:
                     vs = g(vs)
@@ -545,6 +558,15 @@ def test():
                  lambda x, y: (x * 2, y + 1))
     assert (a, b) == (4, 3)
 
+    try:
+        a, b = pipec((1, 2),
+                     lambda x: x + 1,
+                     lambda x: x * 2)
+    except TypeError:
+        pass
+    else:
+        assert False  # error if the curry context exits with args remaining
+
     # optional shell-like syntax
     assert piped1(42) | double | inc | getvalue == 85
 
