la2 reorder

src/flow/binary.rs

@@ -59,24 +59,20 @@ pub trait BinaryTreesMutable<'a>: BinaryTrees<'a> {
             return <Self::T as Pure>::pure(tl)
         };
         let ctx = self.clone();
-        <Self::T as Monad>::join(<Self::T as ApplicativeLA2>::la2(
+        Self::T::bind2(self.resolve(&rl), self.resolve(&rr), move |nl, nr| {
-            move |nl, nr| {
+            let (tll, tlr, kl) = ctx.split(&nl);
-                let (tll, tlr, kl) = ctx.split(&nl);
+            let (trl, trr, kr) = ctx.split(&nr);
-                let (trl, trr, kr) = ctx.split(&nr);
+            let ft = ctx.join(tlr, trl);
-                let ft = ctx.join(tlr, trl);
+            let ft = {
-                let ft = {
+                let ctx = ctx.clone();
-                    let ctx = ctx.clone();
+                <Self::T as Monad>::bind(ft, move |t| ctx.join_key_tree(tll, kl, t))
-                    <Self::T as Monad>::bind(ft, move |t| ctx.join_key_tree(tll, kl, t))
+            };
-                };
+            let ft = {
-                let ft = {
+                let ctx = ctx.clone();
-                    let ctx = ctx.clone();
+                <Self::T as Monad>::bind(ft, move |t| ctx.join_key_tree(t, kr, trr))
-                    <Self::T as Monad>::bind(ft, move |t| ctx.join_key_tree(t, kr, trr))
+            };
-                };
+            ft
-                ft
+        })
-            },
-            self.resolve(&rl),
-            self.resolve(&rr),
-        ))
     }
 
     fn split_key_empty(

src/flow/traversible/algorithms/subset.rs

@@ -17,10 +17,8 @@ struct SubsetContext<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> {
 impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a, T, A, D> {
     fn on_l(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::F<()> {
         T::la2(
-            and,
             algorithms::contains::t_contains(self.comparator, self.t_superl.clone(), k_sub.clone()),
             T::la2(
-                and,
                 t_subset_of_t(
                     self.comparator,
                     t_subl,
@@ -35,13 +33,14 @@ impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a,
                     Some(k_sub),
                     self.k_r,
                 ),
+                and,
             ),
+            and,
         )
     }
 
     fn on_e(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::F<()> {
         T::la2(
-            and,
             t_subset_of_t(
                 self.comparator,
                 t_subl,
@@ -56,15 +55,14 @@ impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a,
                 Some(k_sub),
                 self.k_r,
             ),
+            and,
         )
     }
 
     fn on_r(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::F<()> {
         T::la2(
-            and,
             algorithms::contains::t_contains(self.comparator, self.t_superr.clone(), k_sub.clone()),
             T::la2(
-                and,
                 t_subset_of_t(
                     self.comparator,
                     t_subl,
@@ -79,7 +77,9 @@ impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a,
                     Some(k_sub),
                     self.k_r,
                 ),
+                and,
             ),
+            and,
         )
     }
 
@@ -134,11 +134,11 @@ pub fn r_subset_of_r<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>(
     k_l: Option<Rc<A>>,
     k_r: Option<Rc<A>>,
 ) -> T::F<()> {
-    T::join(T::la2(
+    T::bind2(
-        move |n_subset, n_superset| n_subset_of_n(comparator, n_subset, n_superset, k_l, k_r),
         r_subset.resolve(),
         r_superset.resolve(),
-    ))
+        move |n_subset, n_superset| n_subset_of_n(comparator, n_subset, n_superset, k_l, k_r),
+    )
 }
 
 pub fn t_subset_of_t<'a, T: MonadFail<'a, ()>, A, D: 'a + PartialEq>(

src/func.rs

@@ -86,9 +86,9 @@ pub trait ApplicativeSeq<'a>: Functor<'a> {
 pub trait ApplicativeLA2<'a>: Functor<'a> {
     /// Equivalent of Haskell's `listA2`.
     fn la2<A: 'a, B: 'a, C: 'a>(
-        f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<A>,
         fb: Self::F<B>,
+        f: impl 'a + FnOnce(A, B) -> C,
     ) -> Self::F<C>;
 }
 
@@ -112,7 +112,7 @@ pub trait Applicative<'a>:
 
     /// Equivalent of Haskell's `<*`.
     fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
-        Self::la2(|a, _| a, fa, fb)
+        Self::la2(fa, fb, |a, _| a)
     }
 }
 
@@ -154,7 +154,7 @@ pub trait MonadExt<'a>: Monad<'a> {
         fb: Self::F<B>,
         f: impl 'a + FnOnce(A, B) -> Self::F<C>,
     ) -> Self::F<C> {
-        Self::join(Self::la2(f, fa, fb))
+        Self::join(Self::la2(fa, fb, f))
     }
 }
 

src/func/derivations.rs

@@ -33,7 +33,7 @@ pub trait ApplicativeSeqViaLA2<'a>: ApplicativeLA2<'a> {
         ff: Self::F<impl 'a + FnOnce(A) -> B>,
         fa: Self::F<A>,
     ) -> Self::F<B> {
-        Self::la2(|f, a| f(a), ff, fa)
+        Self::la2(ff, fa, |f, a| f(a))
     }
 }
 
@@ -41,7 +41,7 @@ impl<'a, T: ApplicativeLA2<'a>> ApplicativeSeqViaLA2<'a> for T {}
 
 pub trait ApplicativeTupleViaLA2<'a>: ApplicativeLA2<'a> {
     fn _tuple_via_la2<A: 'a, B: 'a>((fa, fb): (Self::F<A>, Self::F<B>)) -> Self::F<(A, B)> {
-        Self::la2(|a, b| (a, b), fa, fb)
+        Self::la2(fa, fb, |a, b| (a, b))
     }
 }
 

src/func/instances/composition.rs

@@ -39,7 +39,7 @@ impl<'a, U: ApplicativeLA2<'a>, V: ApplicativeSeq<'a>> ApplicativeSeq<'a>
     for CompositionInstance<U, V>
 {
     fn seq<A: 'a, B: 'a>(ff: Self::F<impl 'a + FnOnce(A) -> B>, fa: Self::F<A>) -> Self::F<B> {
-        U::la2(|uf, ua| V::seq(uf, ua), ff, fa)
+        U::la2(ff, fa, V::seq)
     }
 }
 
@@ -47,11 +47,11 @@ impl<'a, U: ApplicativeLA2<'a>, V: ApplicativeLA2<'a>> ApplicativeLA2<'a>
     for CompositionInstance<U, V>
 {
     fn la2<A: 'a, B: 'a, C: 'a>(
-        f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<A>,
         fb: Self::F<B>,
+        f: impl 'a + FnOnce(A, B) -> C,
     ) -> Self::F<C> {
-        U::la2(|ua, ub| V::la2(f, ua, ub), fa, fb)
+        U::la2(fa, fb, |ua, ub| V::la2(ua, ub, f))
     }
 }
 
@@ -80,11 +80,11 @@ impl<'a, U: ApplicativeSelect<'a>, V: Functor<'a>> ApplicativeSelect<'a>
 
 impl<'a, U: Applicative<'a>, V: Applicative<'a>> Applicative<'a> for CompositionInstance<U, V> {
     fn discard_first<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<B> {
-        U::la2(|ua, ub| V::discard_first(ua, ub), fa, fb)
+        U::la2(fa, fb, V::discard_first)
     }
 
     fn discard_second<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> Self::F<A> {
-        U::la2(|ua, ub| V::discard_second(ua, ub), fa, fb)
+        U::la2(fa, fb, V::discard_second)
     }
 }
 

src/func/instances/effect.rs

@@ -82,9 +82,9 @@ impl<'a, E: 'a + Effect> ApplicativeSeq<'a> for EffectInstance<E> {
 
 impl<'a, E: 'a + Effect> ApplicativeLA2<'a> for EffectInstance<E> {
     fn la2<A: 'a, B: 'a, C: 'a>(
-        f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<A>,
         fb: Self::F<B>,
+        f: impl 'a + FnOnce(A, B) -> C,
     ) -> Self::F<C> {
         WithEffect {
             value: f(fa.value, fb.value),

src/func/instances/future.rs

@@ -52,9 +52,9 @@ impl<'a> ApplicativeSeq<'a> for FutureInstance {
 
 impl<'a> ApplicativeLA2<'a> for FutureInstance {
     fn la2<A: 'a, B: 'a, C: 'a>(
-        f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<A>,
         fb: Self::F<B>,
+        f: impl 'a + FnOnce(A, B) -> C,
     ) -> Self::F<C> {
         Box::pin(async {
             let (a, b) = join!(fa, fb);

src/func/instances/lazy.rs

@@ -49,9 +49,9 @@ impl<'a> ApplicativeSeq<'a> for LazyInstance {
 
 impl<'a> ApplicativeLA2<'a> for LazyInstance {
     fn la2<A: 'a, B: 'a, C: 'a>(
-        f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<A>,
         fb: Self::F<B>,
+        f: impl 'a + FnOnce(A, B) -> C,
     ) -> Self::F<C> {
         Box::new(|| f(fa(), fb()))
     }

src/func/instances/option.rs

@@ -50,9 +50,9 @@ impl<'a> ApplicativeSeq<'a> for OptionInstance {
 
 impl<'a> ApplicativeLA2<'a> for OptionInstance {
     fn la2<A: 'a, B: 'a, C: 'a>(
-        f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<A>,
         fb: Self::F<B>,
+        f: impl 'a + FnOnce(A, B) -> C,
     ) -> Self::F<C> {
         Self::pure(f(fa?, fb?))
     }

src/func/instances/overload.rs

@@ -56,11 +56,11 @@ impl<'a, T: ApplicativeLA2<'a>, O: 'a + DeriveApplicative> ApplicativeLA2<'a>
     for OverloadInstance<T, O>
 {
     fn la2<A: 'a, B: 'a, C: 'a>(
-        f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<A>,
         fb: Self::F<B>,
+        f: impl 'a + FnOnce(A, B) -> C,
     ) -> Self::F<C> {
-        T::la2(f, fa, fb)
+        T::la2(fa, fb, f)
     }
 }
 

src/func/instances/result.rs

@@ -50,9 +50,9 @@ impl<'a, E: 'a> ApplicativeSeq<'a> for ResultInstance<E> {
 
 impl<'a, E: 'a> ApplicativeLA2<'a> for ResultInstance<E> {
     fn la2<A: 'a, B: 'a, C: 'a>(
-        f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<A>,
         fb: Self::F<B>,
+        f: impl 'a + FnOnce(A, B) -> C,
     ) -> Self::F<C> {
         Self::pure(f(fa?, fb?))
     }

src/func/instances/solo.rs

@@ -44,9 +44,9 @@ impl<'a> ApplicativeSeq<'a> for SoloInstance {
 
 impl<'a> ApplicativeLA2<'a> for SoloInstance {
     fn la2<A: 'a, B: 'a, C: 'a>(
-        f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<A>,
         fb: Self::F<B>,
+        f: impl 'a + FnOnce(A, B) -> C,
     ) -> Self::F<C> {
         f(fa, fb)
     }

src/func/instances/stackless.rs

@@ -157,9 +157,9 @@ impl<'a> ApplicativeSeq<'a> for StacklessInstance {
 
 impl<'a> ApplicativeLA2<'a> for StacklessInstance {
     fn la2<A: 'a, B: 'a, C: 'a>(
-        f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<A>,
         fb: Self::F<B>,
+        f: impl 'a + FnOnce(A, B) -> C,
     ) -> Self::F<C> {
         Self::_la2_via_seq(f, fa, fb)
     }

src/func/instances/tryfuture.rs

@@ -51,9 +51,9 @@ impl<'a, E: 'a> ApplicativeSeq<'a> for TryFutureInstance<E> {
 
 impl<'a, E: 'a> ApplicativeLA2<'a> for TryFutureInstance<E> {
     fn la2<A: 'a, B: 'a, C: 'a>(
-        f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<A>,
         fb: Self::F<B>,
+        f: impl 'a + FnOnce(A, B) -> C,
     ) -> Self::F<C> {
         Box::pin(async {
             let (a, b) = try_join!(fa, fb)?;

src/func/tests.rs

@@ -188,7 +188,7 @@ pub fn seq_can_be_expressed_via_la2<
     T::eqr(
         "seq via la2: (<*>) = liftA2 id",
         T::seq(ff0(), fa0()),
-        T::la2(|f, a| f(a), ff0(), fa0()),
+        T::la2(ff0(), fa0(), |f, a| f(a)),
     )
 }
 
@@ -224,7 +224,7 @@ pub fn discard_can_be_expressed_via_seq_or_la2<
     ) + T::eqr(
         "discard via la2: u <* v = liftA2 const u v",
         T::discard_second(fb0(), fa0()),
-        T::la2(|b, _| b, fb0(), fa0()),
+        T::la2(fb0(), fa0(), |b, _| b),
     )
 }