small refactor to improve readability

Technologicat · Technologicat · commit f13f29568de8 · 2018-09-25T02:50:59.000+03:00
diff --git a/unpythonic/fun.py b/unpythonic/fun.py
@@ -406,13 +406,13 @@ def composel1i(iterable):
 def _make_compose(direction):  # "left", "right"
     def compose_two(f, g):
         def composed(*args):
-            # 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.
+            bindings = {}
             if iscurried(f):
-                with dyn.let(_curry_context=(dyn._curry_context, composed)):
-                    a = g(*args)
-            else:
+                # 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.
+                bindings = {"_curry_context": (dyn._curry_context, composed)}
+            with dyn.let(**bindings):
                 a = g(*args)
             # we could duck-test, but this is more predictable for the user
             # (consider chaining functions that manipulate a generator), and
diff --git a/unpythonic/seq.py b/unpythonic/seq.py
@@ -273,22 +273,19 @@ def pipe(values0, *bodys):
     """
     xs = values0
     n = len(bodys)
-    def doit():
-        nonlocal xs
-        if isinstance(xs, tuple):
-            xs = update(*xs)
-        else:
-            xs = update(xs)
     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).
+        bindings = {}
         if iscurried(update) and not islast:
-            with dyn.let(_curry_context=(dyn._curry_context, update)):
-                doit()
-        else:
-            doit()
+            # 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).
+            bindings = {"_curry_context": (dyn._curry_context, update)}
+        with dyn.let(**bindings):
+            if isinstance(xs, tuple):
+                xs = update(*xs)
+            else:
+                xs = update(xs)
     if isinstance(xs, tuple):
         return xs if len(xs) > 1 else xs[0]
     return xs
