coconut-develop 3.0.4.post0.dev7__tar.gz → 3.0.4.post0.dev8__tar.gz

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/DOCS.md

@@ -3505,11 +3505,11 @@ def flip(f, nargs=None) =
     )
 ```
 
-#### `lift`
+#### `lift` and `lift_apart`
 
-**lift**(_func_)
+##### **lift**(_func_)
 
-**lift**(_func_, *_func\_args_, **_func\_kwargs_)
+##### **lift**(_func_, *_func\_args_, **_func\_kwargs_)
 
 Coconut's `lift` built-in is a higher-order function that takes in a function and “lifts” it up so that all of its arguments are functions.
 
@@ -3533,7 +3533,33 @@ def lift(f) = (
 
 `lift` also supports a shortcut form such that `lift(f, *func_args, **func_kwargs)` is equivalent to `lift(f)(*func_args, **func_kwargs)`.
 
-##### Example
+##### **lift\_apart**(_func_)
+
+##### **lift\_apart**(_func_, *_func\_args_, **_func\_kwargs_)
+
+Coconut's `lift_apart` built-in is very similar to `lift`, except instead of duplicating the final arguments to each function, it separates them out.
+
+For a binary function `f(x, y)` and two unary functions `g(z)` and `h(z)`, `lift_apart` works as
+```coconut
+lift_apart(f)(g, h)(z, w) == f(g(z), h(w))
+```
+such that in this case `lift_apart` implements the `D2` combinator.
+
+In the general case, `lift_apart` is equivalent to a pickleable version of
+```coconut
+def lift_apart(f) = (
+    (*func_args, **func_kwargs) =>
+        (*args, **kwargs) =>
+            f(
+                *(f(x) for f, x in zip(func_args, args, strict=True)),
+                **{k: func_kwargs[k](kwargs[k]) for k in func_kwargs.keys() | kwargs.keys()},
+            )
+)
+```
+
+`lift_apart` supports the same shortcut form as `lift`.
+
+##### Examples
 
 **Coconut:**
 ```coconut
@@ -3552,8 +3578,33 @@ def plus_and_times(x, y):
     return x + y, x * y
 ```
 
+**Coconut:**
+```coconut
+first_false_and_last_true = (
+    lift(,)(ident, reversed)
+    ..*> lift_apart(,)(dropwhile$(bool), dropwhile$(not))
+    ..*> lift_apart(,)(.$[0], .$[0])
+)
+```
+
+**Python:**
+```coconut_python
+from itertools import dropwhile
+
+def first_false_and_last_true(xs):
+    rev_xs = reversed(xs)
+    return (
+        next(dropwhile(bool, xs)),
+        next(dropwhile(lambda x: not x, rev_xs)),
+    )
+```
+
 #### `and_then` and `and_then_await`
 
+**and\_then**(_first\_async\_func_, _second\_func_)
+
+**and\_then\_await**(_first\_async\_func_, _second\_async\_func_)
+
 Coconut provides the `and_then` and `and_then_await` built-ins for composing `async` functions. Specifically:
 * To forwards compose an async function `async_f` with a normal function `g` (such that `g` is called on the result of `await`ing `async_f`), write ``async_f `and_then` g``.
 * To forwards compose an async function `async_f` with another async function `async_g` (such that `async_g` is called on the result of `await`ing `async_f`, and then `async_g` is itself awaited), write ``async_f `and_then_await` async_g``.

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coconut-develop
-Version: 3.0.4.post0.dev7
+Version: 3.0.4.post0.dev8
 Summary: Simple, elegant, Pythonic functional programming.
 Home-page: http://coconut-lang.org
 Author: Evan Hubinger
@@ -89,7 +89,7 @@ Description: |logo| Coconut
         __ Sponsor_
         .. _Sponsor: https://opencollective.com/coconut#sponsor
         
-Keywords: functional,programming,language,compiler,pattern,pattern-matching,algebraic,data type,data types,lambda,lambdas,lazy,evaluation,lazy list,lazy lists,tail,recursion,call,recursive,recursive_iterator,infix,function,composition,compose,partial,application,currying,curry,pipeline,pipe,unicode,operator,operators,frozenset,literal,syntax,destructuring,assignment,fold,datamaker,prepattern,iterator,generator,none,coalesce,coalescing,statement,lru_cache,memoization,backport,typing,embed,PEP 622,overrides,islice,itertools,functools,TYPE_CHECKING,Expected,breakpoint,help,reduce,takewhile,dropwhile,tee,count,makedata,consume,process_map,thread_map,addpattern,recursive_generator,fmap,starmap,reiterable,scan,groupsof,memoize,zip_longest,override,flatten,ident,call,safe_call,flip,const,lift,all_equal,collectby,mapreduce,multi_enumerate,cartesian_product,multiset,cycle,windowsof,and_then,and_then_await,async_map,py_chr,py_dict,py_hex,py_input,py_int,py_map,py_object,py_oct,py_open,py_print,py_range,py_str,py_super,py_zip,py_filter,py_reversed,py_enumerate,py_raw_input,py_xrange,py_repr,py_breakpoint,_namedtuple_of,reveal_type,reveal_locals,MatchError,ExceptionGroup,BaseExceptionGroup,__fmap__,__iter_getitem__,data,match,case,cases,where,addpattern,then,operator,type,copyclosure,λ
+Keywords: functional,programming,language,compiler,pattern,pattern-matching,algebraic,data type,data types,lambda,lambdas,lazy,evaluation,lazy list,lazy lists,tail,recursion,call,recursive,recursive_iterator,infix,function,composition,compose,partial,application,currying,curry,pipeline,pipe,unicode,operator,operators,frozenset,literal,syntax,destructuring,assignment,fold,datamaker,prepattern,iterator,generator,none,coalesce,coalescing,statement,lru_cache,memoization,backport,typing,embed,PEP 622,overrides,islice,itertools,functools,TYPE_CHECKING,Expected,breakpoint,help,reduce,takewhile,dropwhile,tee,count,makedata,consume,process_map,thread_map,addpattern,recursive_generator,fmap,starmap,reiterable,scan,groupsof,memoize,zip_longest,override,flatten,ident,call,safe_call,flip,const,lift,lift_apart,all_equal,collectby,mapreduce,multi_enumerate,cartesian_product,multiset,cycle,windowsof,and_then,and_then_await,async_map,py_chr,py_dict,py_hex,py_input,py_int,py_map,py_object,py_oct,py_open,py_print,py_range,py_str,py_super,py_zip,py_filter,py_reversed,py_enumerate,py_raw_input,py_xrange,py_repr,py_breakpoint,_namedtuple_of,reveal_type,reveal_locals,MatchError,ExceptionGroup,BaseExceptionGroup,__fmap__,__iter_getitem__,data,match,case,cases,where,addpattern,then,operator,type,copyclosure,λ
 Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: Apache Software License

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/__coconut__/__init__.pyi

@@ -1636,20 +1636,42 @@ def lift(func: _t.Callable[[_T, _U], _W]) -> _coconut_lifted_2[_T, _U, _W]: ...
 def lift(func: _t.Callable[[_T, _U, _V], _W]) -> _coconut_lifted_3[_T, _U, _V, _W]: ...
 @_t.overload
 def lift(func: _t.Callable[..., _W]) -> _t.Callable[..., _t.Callable[..., _W]]:
-    """Lift a function up so that all of its arguments are functions.
+    """Lift a function up so that all of its arguments are functions that all take the same arguments.
 
     For a binary function f(x, y) and two unary functions g(z) and h(z), lift works as the S' combinator:
         lift(f)(g, h)(z) == f(g(z), h(z))
 
     In general, lift is equivalent to:
-        def lift(f) = ((*func_args, **func_kwargs) -> (*args, **kwargs) ->
-            f(*(g(*args, **kwargs) for g in func_args), **{lbrace}k: h(*args, **kwargs) for k, h in func_kwargs.items(){rbrace}))
+        def lift(f) = ((*func_args, **func_kwargs) => (*args, **kwargs) => (
+            f(*(g(*args, **kwargs) for g in func_args), **{k: h(*args, **kwargs) for k, h in func_kwargs.items()}))
+        )
 
     lift also supports a shortcut form such that lift(f, *func_args, **func_kwargs) is equivalent to lift(f)(*func_args, **func_kwargs).
     """
     ...
 _coconut_lift = lift
 
+@_t.overload
+def lift_apart(func: _t.Callable[[_T], _W]) -> _t.Callable[[_t.Callable[[_U], _T]], _t.Callable[[_U], _W]]: ...
+@_t.overload
+def lift_apart(func: _t.Callable[[_T, _X], _W]) -> _t.Callable[[_t.Callable[[_U], _T], _t.Callable[[_Y], _X]], _t.Callable[[_U, _Y], _W]]: ...
+@_t.overload
+def lift_apart(func: _t.Callable[..., _W]) -> _t.Callable[..., _t.Callable[..., _W]]:
+    """Lift a function up so that all of its arguments are functions that each take separate arguments.
+
+    For a binary function f(x, y) and two unary functions g(z) and h(z), lift_apart works as the D2 combinator:
+        lift_apart(f)(g, h)(z, w) == f(g(z), h(w))
+
+    In general, lift_apart is equivalent to:
+        def lift_apart(func) = (*func_args, **func_kwargs) => (*args, **kwargs) => func(
+            *map(call, func_args, args, strict=True),
+            **{k: func_kwargs[k](kwargs[k]) for k in func_kwargs.keys() | kwargs.keys()},
+        )
+
+    lift_apart also supports a shortcut form such that lift_apart(f, *func_args, **func_kwargs) is equivalent to lift_apart(f)(*func_args, **func_kwargs).
+    """
+    ...
+
 
 def all_equal(iterable: _Iterable) -> bool:
     """For a given iterable, check whether all elements in that iterable are equal to each other.

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/coconut/command/command.py

@@ -246,7 +246,6 @@ class Command(object):
                 unset_fast_pyparsing_reprs()
             if args.profile:
                 start_profiling()
-            logger.enable_colors()
 
             logger.log(cli_version)
             if original_args is not None:

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/coconut/compiler/grammar.py

@@ -1381,9 +1381,13 @@ class Grammar(object):
         simple_assign = Forward()
         simple_assign_ref = maybeparens(
             lparen,
-            (setname | passthrough_atom)
-            + ZeroOrMore(ZeroOrMore(complex_trailer) + OneOrMore(simple_trailer)),
-            rparen,
+            (
+                # refname if there's a trailer, setname if not
+                (refname | passthrough_atom) + OneOrMore(ZeroOrMore(complex_trailer) + OneOrMore(simple_trailer))
+                | setname
+                | passthrough_atom
+            ),
+            rparen
         )
         simple_assignlist = maybeparens(lparen, itemlist(simple_assign, comma, suppress_trailing=False), rparen)
 

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/coconut/compiler/header.py

@@ -290,11 +290,15 @@ def process_header_args(which, use_hash, target, no_tco, strict, no_wrap):
         report_this_text=report_this_text,
         from_None=" from None" if target.startswith("3") else "",
         process_="process_" if target_info >= (3, 13) else "",
-
         numpy_modules=tuple_str_of(numpy_modules, add_quotes=True),
         pandas_numpy_modules=tuple_str_of(pandas_numpy_modules, add_quotes=True),
         jax_numpy_modules=tuple_str_of(jax_numpy_modules, add_quotes=True),
         self_match_types=tuple_str_of(self_match_types),
+        comma_bytearray=", bytearray" if not target.startswith("3") else "",
+        lstatic="staticmethod(" if not target.startswith("3") else "",
+        rstatic=")" if not target.startswith("3") else "",
+        all_keys="self.func_kwargs.keys() | kwargs.keys()" if target_info >= (3,) else "_coconut.set(self.func_kwargs.keys()) | _coconut.set(kwargs.keys())",
+
         set_super=(
             # we have to use _coconut_super even on the universal target, since once we set __class__ it becomes a local variable
             "super = py_super" if target.startswith("3") else "super = _coconut_super"
@@ -335,9 +339,6 @@ zip_longest = itertools.zip_longest if _coconut_sys.version_info >= (3,) else it
             else "zip_longest = itertools.izip_longest",
             indent=1,
         ),
-        comma_bytearray=", bytearray" if not target.startswith("3") else "",
-        lstatic="staticmethod(" if not target.startswith("3") else "",
-        rstatic=")" if not target.startswith("3") else "",
         zip_iter=prepare(
             r'''
 for items in _coconut.iter(_coconut.zip(*self.iters, strict=self.strict) if _coconut_sys.version_info >= (3, 10) else _coconut.zip_longest(*self.iters, fillvalue=_coconut_sentinel) if self.strict else _coconut.zip(*self.iters)):

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/coconut/compiler/templates/header.py_template

@@ -432,7 +432,7 @@ def and_then(first_async_func, second_func):
             first_async_func: async (**T) -> U,
             second_func: U -> V,
         ) -> async (**T) -> V =
-            async def (*args, **kwargs) -> (
+            async def (*args, **kwargs) => (
                 first_async_func(*args, **kwargs)
                 |> await
                 |> second_func
@@ -447,7 +447,7 @@ def and_then_await(first_async_func, second_async_func):
             first_async_func: async (**T) -> U,
             second_async_func: async U -> V,
         ) -> async (**T) -> V =
-            async def (*args, **kwargs) -> (
+            async def (*args, **kwargs) => (
                 first_async_func(*args, **kwargs)
                 |> await
                 |> second_async_func
@@ -458,98 +458,98 @@ def and_then_await(first_async_func, second_async_func):
 def _coconut_forward_compose(func, *funcs):
     """Forward composition operator (..>).
 
-    (..>)(f, g) is effectively equivalent to (*args, **kwargs) -> g(f(*args, **kwargs))."""
+    (..>)(f, g) is effectively equivalent to (*args, **kwargs) => g(f(*args, **kwargs))."""
     return _coconut_base_compose(func, *((f, 0, False) for f in funcs))
 def _coconut_back_compose(*funcs):
     """Backward composition operator (<..).
 
-    (<..)(f, g) is effectively equivalent to (*args, **kwargs) -> f(g(*args, **kwargs))."""
+    (<..)(f, g) is effectively equivalent to (*args, **kwargs) => f(g(*args, **kwargs))."""
     return _coconut_forward_compose(*_coconut.reversed(funcs))
 def _coconut_forward_none_compose(func, *funcs):
     """Forward none-aware composition operator (..?>).
 
-    (..?>)(f, g) is effectively equivalent to (*args, **kwargs) -> g?(f(*args, **kwargs))."""
+    (..?>)(f, g) is effectively equivalent to (*args, **kwargs) => g?(f(*args, **kwargs))."""
     return _coconut_base_compose(func, *((f, 0, True) for f in funcs))
 def _coconut_back_none_compose(*funcs):
     """Backward none-aware composition operator (<..?).
 
-    (<..?)(f, g) is effectively equivalent to (*args, **kwargs) -> f?(g(*args, **kwargs))."""
+    (<..?)(f, g) is effectively equivalent to (*args, **kwargs) => f?(g(*args, **kwargs))."""
     return _coconut_forward_none_compose(*_coconut.reversed(funcs))
 def _coconut_forward_star_compose(func, *funcs):
     """Forward star composition operator (..*>).
 
-    (..*>)(f, g) is effectively equivalent to (*args, **kwargs) -> g(*f(*args, **kwargs))."""
+    (..*>)(f, g) is effectively equivalent to (*args, **kwargs) => g(*f(*args, **kwargs))."""
     return _coconut_base_compose(func, *((f, 1, False) for f in funcs))
 def _coconut_back_star_compose(*funcs):
     """Backward star composition operator (<*..).
 
-    (<*..)(f, g) is effectively equivalent to (*args, **kwargs) -> f(*g(*args, **kwargs))."""
+    (<*..)(f, g) is effectively equivalent to (*args, **kwargs) => f(*g(*args, **kwargs))."""
     return _coconut_forward_star_compose(*_coconut.reversed(funcs))
 def _coconut_forward_none_star_compose(func, *funcs):
     """Forward none-aware star composition operator (..?*>).
 
-    (..?*>)(f, g) is effectively equivalent to (*args, **kwargs) -> g?(*f(*args, **kwargs))."""
+    (..?*>)(f, g) is effectively equivalent to (*args, **kwargs) => g?(*f(*args, **kwargs))."""
     return _coconut_base_compose(func, *((f, 1, True) for f in funcs))
 def _coconut_back_none_star_compose(*funcs):
     """Backward none-aware star composition operator (<*?..).
 
-    (<*?..)(f, g) is effectively equivalent to (*args, **kwargs) -> f?(*g(*args, **kwargs))."""
+    (<*?..)(f, g) is effectively equivalent to (*args, **kwargs) => f?(*g(*args, **kwargs))."""
     return _coconut_forward_none_star_compose(*_coconut.reversed(funcs))
 def _coconut_forward_dubstar_compose(func, *funcs):
     """Forward double star composition operator (..**>).
 
-    (..**>)(f, g) is effectively equivalent to (*args, **kwargs) -> g(**f(*args, **kwargs))."""
+    (..**>)(f, g) is effectively equivalent to (*args, **kwargs) => g(**f(*args, **kwargs))."""
     return _coconut_base_compose(func, *((f, 2, False) for f in funcs))
 def _coconut_back_dubstar_compose(*funcs):
     """Backward double star composition operator (<**..).
 
-    (<**..)(f, g) is effectively equivalent to (*args, **kwargs) -> f(**g(*args, **kwargs))."""
+    (<**..)(f, g) is effectively equivalent to (*args, **kwargs) => f(**g(*args, **kwargs))."""
     return _coconut_forward_dubstar_compose(*_coconut.reversed(funcs))
 def _coconut_forward_none_dubstar_compose(func, *funcs):
     """Forward none-aware double star composition operator (..?**>).
 
-    (..?**>)(f, g) is effectively equivalent to (*args, **kwargs) -> g?(**f(*args, **kwargs))."""
+    (..?**>)(f, g) is effectively equivalent to (*args, **kwargs) => g?(**f(*args, **kwargs))."""
     return _coconut_base_compose(func, *((f, 2, True) for f in funcs))
 def _coconut_back_none_dubstar_compose(*funcs):
     """Backward none-aware double star composition operator (<**?..).
 
-    (<**?..)(f, g) is effectively equivalent to (*args, **kwargs) -> f?(**g(*args, **kwargs))."""
+    (<**?..)(f, g) is effectively equivalent to (*args, **kwargs) => f?(**g(*args, **kwargs))."""
     return _coconut_forward_none_dubstar_compose(*_coconut.reversed(funcs))
 def _coconut_pipe(x, f):
-    """Pipe operator (|>). Equivalent to (x, f) -> f(x)."""
+    """Pipe operator (|>). Equivalent to (x, f) => f(x)."""
     return f(x)
 def _coconut_star_pipe(xs, f):
-    """Star pipe operator (*|>). Equivalent to (xs, f) -> f(*xs)."""
+    """Star pipe operator (*|>). Equivalent to (xs, f) => f(*xs)."""
     return f(*xs)
 def _coconut_dubstar_pipe(kws, f):
-    """Double star pipe operator (**|>). Equivalent to (kws, f) -> f(**kws)."""
+    """Double star pipe operator (**|>). Equivalent to (kws, f) => f(**kws)."""
     return f(**kws)
 def _coconut_back_pipe(f, x):
-    """Backward pipe operator (<|). Equivalent to (f, x) -> f(x)."""
+    """Backward pipe operator (<|). Equivalent to (f, x) => f(x)."""
     return f(x)
 def _coconut_back_star_pipe(f, xs):
-    """Backward star pipe operator (<*|). Equivalent to (f, xs) -> f(*xs)."""
+    """Backward star pipe operator (<*|). Equivalent to (f, xs) => f(*xs)."""
     return f(*xs)
 def _coconut_back_dubstar_pipe(f, kws):
-    """Backward double star pipe operator (<**|). Equivalent to (f, kws) -> f(**kws)."""
+    """Backward double star pipe operator (<**|). Equivalent to (f, kws) => f(**kws)."""
     return f(**kws)
 def _coconut_none_pipe(x, f):
-    """Nullable pipe operator (|?>). Equivalent to (x, f) -> f(x) if x is not None else None."""
+    """Nullable pipe operator (|?>). Equivalent to (x, f) => f(x) if x is not None else None."""
     return None if x is None else f(x)
 def _coconut_none_star_pipe(xs, f):
-    """Nullable star pipe operator (|?*>). Equivalent to (xs, f) -> f(*xs) if xs is not None else None."""
+    """Nullable star pipe operator (|?*>). Equivalent to (xs, f) => f(*xs) if xs is not None else None."""
     return None if xs is None else f(*xs)
 def _coconut_none_dubstar_pipe(kws, f):
-    """Nullable double star pipe operator (|?**>). Equivalent to (kws, f) -> f(**kws) if kws is not None else None."""
+    """Nullable double star pipe operator (|?**>). Equivalent to (kws, f) => f(**kws) if kws is not None else None."""
     return None if kws is None else f(**kws)
 def _coconut_back_none_pipe(f, x):
-    """Nullable backward pipe operator (<?|). Equivalent to (f, x) -> f(x) if x is not None else None."""
+    """Nullable backward pipe operator (<?|). Equivalent to (f, x) => f(x) if x is not None else None."""
     return None if x is None else f(x)
 def _coconut_back_none_star_pipe(f, xs):
-    """Nullable backward star pipe operator (<*?|). Equivalent to (f, xs) -> f(*xs) if xs is not None else None."""
+    """Nullable backward star pipe operator (<*?|). Equivalent to (f, xs) => f(*xs) if xs is not None else None."""
     return None if xs is None else f(*xs)
 def _coconut_back_none_dubstar_pipe(f, kws):
-    """Nullable backward double star pipe operator (<**?|). Equivalent to (kws, f) -> f(**kws) if kws is not None else None."""
+    """Nullable backward double star pipe operator (<**?|). Equivalent to (kws, f) => f(**kws) if kws is not None else None."""
     return None if kws is None else f(**kws)
 def _coconut_assert(cond, msg=None):
     """Assert operator (assert). Asserts condition with optional message."""
@@ -563,27 +563,27 @@ def _coconut_raise(exc=None, from_exc=None):
         exc.__cause__ = from_exc
     raise exc
 def _coconut_bool_and(a, b):
-    """Boolean and operator (and). Equivalent to (a, b) -> a and b."""
+    """Boolean and operator (and). Equivalent to (a, b) => a and b."""
     return a and b
 def _coconut_bool_or(a, b):
-    """Boolean or operator (or). Equivalent to (a, b) -> a or b."""
+    """Boolean or operator (or). Equivalent to (a, b) => a or b."""
     return a or b
 def _coconut_in(a, b):
-    """Containment operator (in). Equivalent to (a, b) -> a in b."""
+    """Containment operator (in). Equivalent to (a, b) => a in b."""
     return a in b
 def _coconut_not_in(a, b):
-    """Negative containment operator (not in). Equivalent to (a, b) -> a not in b."""
+    """Negative containment operator (not in). Equivalent to (a, b) => a not in b."""
     return a not in b
 def _coconut_none_coalesce(a, b):
-    """None coalescing operator (??). Equivalent to (a, b) -> a if a is not None else b."""
+    """None coalescing operator (??). Equivalent to (a, b) => a if a is not None else b."""
     return b if a is None else a
 def _coconut_minus(a, b=_coconut_sentinel):
-    """Minus operator (-). Effectively equivalent to (a, b=None) -> a - b if b is not None else -a."""
+    """Minus operator (-). Effectively equivalent to (a, b=None) => a - b if b is not None else -a."""
     if b is _coconut_sentinel:
         return -a
     return a - b
 def _coconut_comma_op(*args):
-    """Comma operator (,). Equivalent to (*args) -> args."""
+    """Comma operator (,). Equivalent to (*args) => args."""
     return args
 {def_coconut_matmul}
 class scan(_coconut_has_iter):
@@ -1678,7 +1678,7 @@ def _coconut_dict_merge(*dicts, **kwargs):
             prevlen = _coconut.len(newdict)
     return newdict
 def ident(x, **kwargs):
-    """The identity function. Generally equivalent to x -> x. Useful in point-free programming.
+    """The identity function. Generally equivalent to x => x. Useful in point-free programming.
     Accepts one keyword-only argument, side_effect, which specifies a function to call on the argument before it is returned."""
     side_effect = kwargs.pop("side_effect", None)
     if kwargs:
@@ -1874,30 +1874,36 @@ class const(_coconut_base_callable):
     def __repr__(self):
         return "const(%s)" % (_coconut.repr(self.value),)
 class _coconut_lifted(_coconut_base_callable):
-    __slots__ = ("func", "func_args", "func_kwargs")
-    def __init__(self, _coconut_func, *func_args, **func_kwargs):
-        self.func = _coconut_func
+    __slots__ = ("apart", "func", "func_args", "func_kwargs")
+    def __init__(self, apart, func, func_args, func_kwargs):
+        self.apart = apart
+        self.func = func
         self.func_args = func_args
         self.func_kwargs = func_kwargs
     def __reduce__(self):
-        return (self.__class__, (self.func,) + self.func_args, {lbrace}"func_kwargs": self.func_kwargs{rbrace})
+        return (self.__class__, (self.apart, self.func, self.func_args, self.func_kwargs))
     def __call__(self, *args, **kwargs):
-        return self.func(*(g(*args, **kwargs) for g in self.func_args), **_coconut_py_dict((k, h(*args, **kwargs)) for k, h in self.func_kwargs.items()))
+        if self.apart:
+            return self.func(*(f(x) for f, x in {_coconut_}zip(self.func_args, args, strict=True)), **_coconut_py_dict((k, self.func_kwargs[k](kwargs[k])) for k in {all_keys}))
+        else:
+            return self.func(*(g(*args, **kwargs) for g in self.func_args), **_coconut_py_dict((k, h(*args, **kwargs)) for k, h in self.func_kwargs.items()))
     def __repr__(self):
-        return "lift(%r)(%s%s)" % (self.func, ", ".join(_coconut.repr(g) for g in self.func_args), ", ".join(k + "=" + _coconut.repr(h) for k, h in self.func_kwargs.items()))
+        return "lift%s(%r)(%s%s)" % (self.func, ("_apart" if self.apart else ""), ", ".join(_coconut.repr(g) for g in self.func_args), ", ".join(k + "=" + _coconut.repr(h) for k, h in self.func_kwargs.items()))
 class lift(_coconut_base_callable):
-    """Lift a function up so that all of its arguments are functions.
+    """Lift a function up so that all of its arguments are functions that all take the same arguments.
 
     For a binary function f(x, y) and two unary functions g(z) and h(z), lift works as the S' combinator:
         lift(f)(g, h)(z) == f(g(z), h(z))
 
     In general, lift is equivalent to:
-        def lift(f) = ((*func_args, **func_kwargs) -> (*args, **kwargs) ->
+        def lift(f) = ((*func_args, **func_kwargs) => (*args, **kwargs) => (
             f(*(g(*args, **kwargs) for g in func_args), **{lbrace}k: h(*args, **kwargs) for k, h in func_kwargs.items(){rbrace}))
+        )
 
     lift also supports a shortcut form such that lift(f, *func_args, **func_kwargs) is equivalent to lift(f)(*func_args, **func_kwargs).
     """
     __slots__ = ("func",)
+    _apart = False
     def __new__(cls, func, *func_args, **func_kwargs):
         self = _coconut.super({_coconut_}lift, cls).__new__(cls)
         self.func = func
@@ -1907,9 +1913,24 @@ class lift(_coconut_base_callable):
     def __reduce__(self):
         return (self.__class__, (self.func,))
     def __repr__(self):
-        return "lift(%r)" % (self.func,)
+        return "lift%s(%r)" % (("_apart" if self._apart else ""), self.func)
     def __call__(self, *func_args, **func_kwargs):
-        return _coconut_lifted(self.func, *func_args, **func_kwargs)
+        return _coconut_lifted(self._apart, self.func, func_args, func_kwargs)
+class lift_apart(lift):
+    """Lift a function up so that all of its arguments are functions that each take separate arguments.
+
+    For a binary function f(x, y) and two unary functions g(z) and h(z), lift_apart works as the D2 combinator:
+        lift_apart(f)(g, h)(z, w) == f(g(z), h(w))
+
+    In general, lift_apart is equivalent to:
+        def lift_apart(func) = (*func_args, **func_kwargs) => (*args, **kwargs) => func(
+            *(f(x) for f, x in zip(func_args, args, strict=True)),
+            **{lbrace}k: func_kwargs[k](kwargs[k]) for k in func_kwargs.keys() | kwargs.keys(){rbrace},
+        )
+
+    lift_apart also supports a shortcut form such that lift_apart(f, *func_args, **func_kwargs) is equivalent to lift_apart(f)(*func_args, **func_kwargs).
+    """
+    _apart = True
 def all_equal(iterable):
     """For a given iterable, check whether all elements in that iterable are equal to each other.
 
@@ -1974,7 +1995,7 @@ def collectby(key_func, iterable, value_func=None, **kwargs):
     If map_using is passed, calculate key_func and value_func by mapping them over
     the iterable using map_using as map. Useful with process_map/thread_map.
     """
-    return {_coconut_}mapreduce(_coconut_lifted(_coconut_comma_op, key_func, {_coconut_}ident if value_func is None else value_func), iterable, **kwargs)
+    return {_coconut_}mapreduce(_coconut_lifted(False, _coconut_comma_op, (key_func, {_coconut_}ident if value_func is None else value_func), {empty_dict}), iterable, **kwargs)
 collectby.using_processes = _coconut_partial(_coconut_parallel_mapreduce, collectby, process_map)
 collectby.using_threads = _coconut_partial(_coconut_parallel_mapreduce, collectby, thread_map)
 def _namedtuple_of(**kwargs):

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/coconut/constants.py

@@ -639,7 +639,7 @@ force_verbose_logger = get_bool_env_var("COCONUT_FORCE_VERBOSE", False)
 
 coconut_home = get_path_env_var(home_env_var, "~")
 
-use_color = get_bool_env_var("COCONUT_USE_COLOR", None)
+use_color_env_var = "COCONUT_USE_COLOR"
 error_color_code = "31"
 log_color_code = "93"
 
@@ -794,6 +794,7 @@ coconut_specific_builtins = (
     "flip",
     "const",
     "lift",
+    "lift_apart",
     "all_equal",
     "collectby",
     "mapreduce",

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/coconut/root.py

@@ -26,7 +26,7 @@ import sys as _coconut_sys
 VERSION = "3.0.4"
 VERSION_NAME = None
 # False for release, int >= 1 for develop
-DEVELOP = 7
+DEVELOP = 8
 ALPHA = False  # for pre releases rather than post releases
 
 assert DEVELOP is False or DEVELOP >= 1, "DEVELOP must be False or an int >= 1"

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/coconut/terminal.py

@@ -47,7 +47,8 @@ from coconut.constants import (
     taberrfmt,
     use_packrat_parser,
     embed_on_internal_exc,
-    use_color,
+    use_color_env_var,
+    get_bool_env_var,
     error_color_code,
     log_color_code,
     ansii_escape,
@@ -209,6 +210,7 @@ class Logger(object):
     @classmethod
     def enable_colors(cls, file=None):
         """Attempt to enable CLI colors."""
+        use_color = get_bool_env_var(use_color_env_var)
         if (
             use_color is False
             or use_color is None and file is not None and not isatty(file)

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/coconut/tests/src/cocotest/agnostic/suite.coco

@@ -1029,7 +1029,7 @@ forward 2""") == 900
     assert Phi((,), (.+1), (.-1)) <| 5 == (6, 4)
     assert Psi((,), (.+1), 3) <| 4 == (4, 5)
     assert D1((,), 0, 1, (.+1)) <| 1 == (0, 1, 2)
-    assert D2((+), (.*2), 3, (.+1)) <| 4 == 11
+    assert D2((+), (.*2), 3, (.+1)) <| 4 == 11 == D2_((+), (.*2), (.+1))(3, 4)
     assert E((+), 10, (*), 2) <| 3 == 16
     assert Phi1((,), (+), (*), 2) <| 3 == (5, 6)
     assert BE((,), (+), 10, 2, (*), 2) <| 3 == (12, 6)
@@ -1075,6 +1075,8 @@ forward 2""") == 900
     assert pickle_round_trip(.loc[0]) <| (loc=[10]) == 10
     assert pickle_round_trip(.method(0)) <| (method=const 10) == 10
     assert pickle_round_trip(.method(x=10)) <| (method=x -> x) == 10
+    assert sq_and_t2p1(10) == (100, 21)
+    assert first_false_and_last_true([3, 2, 1, 0, "11", "1", ""]) == (0, "1")
 
     with process_map.multiple_sequential_calls():  # type: ignore
         assert process_map(tuple <.. (|>)$(to_sort), qsorts) |> list == [to_sort |> sorted |> tuple] * len(qsorts)

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/coconut/tests/src/cocotest/agnostic/util.coco

@@ -1544,6 +1544,24 @@ def BE(f, g, x, y, h, z) = lift(f)(const(g x y), h$(z))
 
 def on(b, u) = (,) ..> map$(u) ..*> b
 
+def D2_(f, g, h) = lift_apart(f)(g, h)
+
+
+# branching
+branch = lift(,)
+branched = lift_apart(,)
+
+sq_and_t2p1 = (
+    branch(ident, (.*2))
+    ..*> branched((.**2), (.+1))  # type: ignore
+)
+
+first_false_and_last_true = (
+    lift(,)(ident, reversed)
+    ..*> lift_apart(,)(dropwhile$(bool), dropwhile$(not))  # type: ignore
+    ..*> lift_apart(,)(.$[0], .$[0])  # type: ignore
+)
+
 
 # maximum difference
 def maxdiff1(ns) = (

{coconut-develop-3.0.4.post0.dev7 → coconut-develop-3.0.4.post0.dev8}/coconut/tests/src/extras.coco

@@ -1,5 +1,8 @@
+import os
 from collections.abc import Sequence
 
+os.environ["COCONUT_USE_COLOR"] = "False"
+
 from coconut.__coconut__ import consume as coc_consume
 from coconut.constants import (
     IPY,