more logical suffix ordering in compose functions

Technologicat · Technologicat · commit 648e0e3bede9 · 2018-09-17T09:29:49.000+03:00
diff --git a/unpythonic/fun.py b/unpythonic/fun.py
@@ -11,9 +11,9 @@
 __all__ = ["memoize", "curry", "iscurried",
            "flip", "rotate",
            "apply", "identity", "const", "notf", "andf", "orf",
-           "composer1", "composel1", "composeri1", "composeli1",  # single arg
+           "composer1", "composel1", "composer1i", "composel1i",  # single arg
            "composer",  "composel",  "composeri",  "composeli",   # multi-arg
-           "composerc", "composelc", "composeric", "composelic",  # multi-arg w/ curry
+           "composerc", "composelc", "composerci", "composelci",  # multi-arg w/ curry
            "to1st", "to2nd", "tokth", "tolast", "to"]
 
 from functools import wraps, partial
@@ -110,9 +110,9 @@ def foo(a, b, *, c, d):
     on the remaining positional args::
 
         map_one = lambda f: (curry(foldr))(composer(cons, to1st(f)), nil)
-        assert curry(map_one)(double, (1, 2, 3)) == (2, 4, 6)
+        assert curry(map_one)(double, ll(1, 2, 3)) == ll(2, 4, 6)
 
-    In the above example, ``map_one`` has arity 1, so the tuple ``(1, 2, 3)``
+    In the above example, ``map_one`` has arity 1, so the arg ``ll(1, 2, 3)``
     is extra. The result of ``map_one`` is a callable, so it is then
     invoked on this tuple.
 
@@ -131,6 +131,10 @@ def foo(a, b, *, c, d):
 
         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)
+
         from functools import partial
         from unpythonic import curry, composel, drop, take
 
@@ -360,7 +364,7 @@ def composer1(*fs):
         inc_then_double = composer1(double, inc)
         assert inc_then_double(3) == 8
     """
-    return composeri1(fs)
+    return composer1i(fs)
 
 def composel1(*fs):
     """Like composel, but limited to one-argument functions. Faster.
@@ -369,17 +373,17 @@ def composel1(*fs):
 
         double = lambda x: 2*x
         inc    = lambda x: x+1
-        double_then_inc = composel(double, inc)
+        double_then_inc = composel1(double, inc)
         assert double_then_inc(3) == 7
     """
-    return composeli1(fs)
+    return composel1i(fs)
 
-def composeri1(iterable):  # this is just to insert a docstring
-    """Like composeri, but limited to one-argument functions. Faster."""
+def composer1i(iterable):  # this is just to insert a docstring
+    """Like composer1, but read the functions from an iterable."""
     return _compose1_right(iterable)
 
-def composeli1(iterable):
-    """Like composeli, but limited to one-argument functions. Faster."""
+def composel1i(iterable):
+    """Like composel1, but read the functions from an iterable."""
     return _compose1_left(iterable)
 
 def _make_compose(direction):  # "left", "right"
@@ -425,15 +429,13 @@ def composel(*fs):
     return composeli(fs)
 
 def composeri(iterable):
-    """Like composer, but takes an iterable of functions to compose."""
+    """Like composer, but read the functions from an iterable."""
     return _compose_right(iterable)
 
 def composeli(iterable):
-    """Like composel, but takes an iterable of functions to compose."""
+    """Like composel, but read the functions from an iterable."""
     return _compose_left(iterable)
 
-
-# currying versions
 def composerc(*fs):
     """Like composer, but curry each function before composing.
 
@@ -445,17 +447,19 @@ def composerc(*fs):
         add = lambda x, y: x + y
         assert curry(mymap, add, ll(1, 2, 3), ll(4, 5, 6)) == ll(5, 7, 9)
     """
-    return composeric(fs)
-def composeric(iterable):
-    """Like composeri, but curry each function before composing."""
-    return composeri(map(curry, iterable))
+    return composerci(fs)
+
 def composelc(*fs):
     """Like composel, but curry each function before composing."""
-    return composelic(fs)
-def composelic(iterable):
-    """Like composeli, but curry each function before composing."""
-    return composeli(map(curry, iterable))
+    return composelci(fs)
+
+def composerci(iterable):
+    """Like composerc, but read the functions from an iterable."""
+    return composeri(map(curry, iterable))
 
+def composelci(iterable):
+    """Like composelc, but read the functions from an iterable."""
+    return composeli(map(curry, iterable))
 
 # Helpers to insert one-in-one-out functions into multi-arg compose chains
 def tokth(k, f):
@@ -485,13 +489,10 @@ def to1st(f):
 
     Example::
 
-        nil = ()
-        def cons(x, l):  # elt, acc
-            return (x,) + l
         def mymap_one(f, sequence):
             f_then_cons = composer(cons, to1st(f))  # args: elt, acc
             return foldr(f_then_cons, nil, sequence)
-        double = lambda x: 2*x
+        double = lambda x: 2 * x
         assert mymap_one(double, (1, 2, 3)) == (2, 4, 6)
     """
     return tokth(0, f)  # this is just a partial() but we want to provide a docstring.
diff --git a/unpythonic/it.py b/unpythonic/it.py
@@ -267,22 +267,11 @@ def flatten_in(iterable, pred=None):
 def test():
     from operator import add, mul, itemgetter
     from functools import partial
+    from unpythonic.fun import curry, composer, composerc, composel, to1st, rotate, identity
+    from unpythonic.llist import cons, nil, ll
 
-    import unpythonic.fun
-    curry = unpythonic.fun.curry
-    composer = unpythonic.fun.composer
-    composerc = unpythonic.fun.composerc
-    composel = unpythonic.fun.composel
-    to1st = unpythonic.fun.to1st
-    rotate = unpythonic.fun.rotate
-    identity = unpythonic.fun.identity
-
-    # just a testing hack; for a "real" cons, see unpythonic.llist.cons
-    nil = ()
-    def cons(x, l):  # elt, acc
-        return (x,) + l
-    assert foldl(cons, nil, (1, 2, 3)) == (3, 2, 1)
-    assert foldr(cons, nil, (1, 2, 3)) == (1, 2, 3)
+    assert foldl(cons, nil, ll(1, 2, 3)) == ll(3, 2, 1)
+    assert foldr(cons, nil, ll(1, 2, 3)) == ll(1, 2, 3)
 
     assert reducel(add, (1, 2, 3)) == 6
     assert reducer(add, (1, 2, 3)) == 6
@@ -296,19 +285,19 @@ def mymap_one(f, sequence):
         f_then_cons = composer(cons, to1st(f))  # args: elt, acc
         return foldr(f_then_cons, nil, sequence)
     double = lambda x: 2 * x
-    assert mymap_one(double, (1, 2, 3)) == (2, 4, 6)
+    assert mymap_one(double, ll(1, 2, 3)) == ll(2, 4, 6)
     def mymap_one2(f, sequence):
         f_then_cons = composel(to1st(f), cons)  # args: elt, acc
         return foldr(f_then_cons, nil, sequence)
-    assert mymap_one2(double, (1, 2, 3)) == (2, 4, 6)
+    assert mymap_one2(double, ll(1, 2, 3)) == ll(2, 4, 6)
 
     # point-free-ish style
     mymap_one3 = lambda f: partial(foldr, composer(cons, to1st(f)), nil)
     doubler = mymap_one3(double)
-    assert doubler((1, 2, 3)) == (2, 4, 6)
+    assert doubler(ll(1, 2, 3)) == ll(2, 4, 6)
 
     try:
-        doubler((1, 2, 3), (4, 5, 6))
+        doubler(ll(1, 2, 3), ll(4, 5, 6))
     except TypeError:
         pass
     else:
@@ -317,25 +306,25 @@ def mymap_one2(f, sequence):
     # minimum arity of fold functions is 3, to allow use with curry:
     mymap_one4 = lambda f: curry(foldr, composer(cons, to1st(f)), nil)
     doubler = mymap_one4(double)
-    assert doubler((1, 2, 3)) == (2, 4, 6)
+    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:
-    assert curry(mymap_one4, double, (1, 2, 3)) == (2, 4, 6)
+    assert curry(mymap_one4, double, ll(1, 2, 3)) == ll(2, 4, 6)
 
     # 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)
-    assert curry(mymap_one5, double, (1, 2, 3)) == (2, 4, 6)
+    assert curry(mymap_one5, double, ll(1, 2, 3)) == ll(2, 4, 6)
 
     # Finally, we can drop the inner curry by using a currying compose.
     # This is as close to "(define (map f) (foldr (compose cons f) empty)"
     # (#lang spicy) as we're gonna get in Python.
     mymap = lambda f: curry(foldr, composerc(cons, f), nil)
-    assert curry(mymap, double, (1, 2, 3)) == (2, 4, 6)
+    assert curry(mymap, double, ll(1, 2, 3)) == ll(2, 4, 6)
 
     # The currying has actually made it not just map one, but general map that
     # accepts multiple input sequences.
@@ -344,21 +333,23 @@ def mymap_one2(f, sequence):
     # argument, is passed through on the right. The output from the processing
     # function - one new item - and acc then become a two-tuple, which gets
     # passed into cons.
-    assert curry(mymap, lambda x, y: x + y, (1, 2, 3), (2, 4, 6)) == (3, 6, 9)
+    add = lambda x, y: x + y
+    assert curry(mymap, add, ll(1, 2, 3), ll(2, 4, 6)) == ll(3, 6, 9)
 
     reverse_one = curry(foldl, cons, nil)
-    assert reverse_one((1, 2, 3)) == (3, 2, 1)
+    assert reverse_one(ll(1, 2, 3)) == ll(3, 2, 1)
 
-    append_two = lambda a, b: foldr(cons, b, a)
-    assert append_two((1, 2, 3), (4, 5, 6)) == (1, 2, 3, 4, 5, 6)
+    append_two = lambda a, b: foldr(cons, b, a)  # a, b: linked lists
+    assert append_two(ll(1, 2, 3), ll(4, 5, 6)) == ll(1, 2, 3, 4, 5, 6)
 
+    # see upythonic.llist.lappend
     append_many = lambda *lsts: foldr(append_two, nil, lsts)
-    assert append_many((1, 2), (3, 4), (5, 6)) == (1, 2, 3, 4, 5, 6)
+    assert append_many(ll(1, 2), ll(3, 4), ll(5, 6)) == ll(1, 2, 3, 4, 5, 6)
 
     mysum = curry(foldl, add, 0)
     myprod = curry(foldl, mul, 1)
-    a = (1, 2)
-    b = (3, 4)
+    a = ll(1, 2)
+    b = ll(3, 4)
     assert mysum(append_two(a, b)) == 10
     assert myprod(b) == 12
 
diff --git a/unpythonic/llist.py b/unpythonic/llist.py
@@ -9,7 +9,7 @@
 from collections.abc import Sequence
 from itertools import zip_longest
 
-from unpythonic.fun import composeri1
+from unpythonic.fun import composer1i
 from unpythonic.it import foldr, foldl
 
 # explicit list better for tooling support
@@ -210,7 +210,7 @@ def _typecheck(x):
 def _build_accessor(name):
     spec = name[1:-1]
     f = {'a': _car, 'd': _cdr}
-    return composeri1(f[char] for char in spec)
+    return composer1i(f[char] for char in spec)
 
 def car(x):
     """Return the first half of a cons cell."""  # no autobuild, we want a docstring.
