From 4794dd1d175097e409e45f93251a92cf84489470 Mon Sep 17 00:00:00 2001 From: timofey Date: Tue, 30 May 2023 00:00:14 +0000 Subject: [PATCH] `la2` reorder --- src/flow/binary.rs | 32 ++++++++++------------- src/flow/traversible/algorithms/subset.rs | 16 ++++++------ src/func.rs | 6 ++--- src/func/derivations.rs | 4 +-- src/func/instances/composition.rs | 10 +++---- src/func/instances/effect.rs | 2 +- src/func/instances/future.rs | 2 +- src/func/instances/lazy.rs | 2 +- src/func/instances/option.rs | 2 +- src/func/instances/overload.rs | 4 +-- src/func/instances/result.rs | 2 +- src/func/instances/solo.rs | 2 +- src/func/instances/stackless.rs | 2 +- src/func/instances/tryfuture.rs | 2 +- src/func/tests.rs | 4 +-- 15 files changed, 44 insertions(+), 48 deletions(-) diff --git a/src/flow/binary.rs b/src/flow/binary.rs index d850223..176173d 100644 --- a/src/flow/binary.rs +++ b/src/flow/binary.rs @@ -59,24 +59,20 @@ pub trait BinaryTreesMutable<'a>: BinaryTrees<'a> { return ::pure(tl) }; let ctx = self.clone(); - ::join(::la2( - move |nl, nr| { - let (tll, tlr, kl) = ctx.split(&nl); - let (trl, trr, kr) = ctx.split(&nr); - let ft = ctx.join(tlr, trl); - let ft = { - let ctx = ctx.clone(); - ::bind(ft, move |t| ctx.join_key_tree(tll, kl, t)) - }; - let ft = { - let ctx = ctx.clone(); - ::bind(ft, move |t| ctx.join_key_tree(t, kr, trr)) - }; - ft - }, - self.resolve(&rl), - self.resolve(&rr), - )) + Self::T::bind2(self.resolve(&rl), self.resolve(&rr), move |nl, nr| { + let (tll, tlr, kl) = ctx.split(&nl); + let (trl, trr, kr) = ctx.split(&nr); + let ft = ctx.join(tlr, trl); + let ft = { + let ctx = ctx.clone(); + ::bind(ft, move |t| ctx.join_key_tree(tll, kl, t)) + }; + let ft = { + let ctx = ctx.clone(); + ::bind(ft, move |t| ctx.join_key_tree(t, kr, trr)) + }; + ft + }) } fn split_key_empty( diff --git a/src/flow/traversible/algorithms/subset.rs b/src/flow/traversible/algorithms/subset.rs index 381ba49..176734b 100644 --- a/src/flow/traversible/algorithms/subset.rs +++ b/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>, k_r: Option>, ) -> T::F<()> { - T::join(T::la2( - move |n_subset, n_superset| n_subset_of_n(comparator, n_subset, n_superset, k_l, k_r), + T::bind2( 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>( diff --git a/src/func.rs b/src/func.rs index 1536899..e2cb46c 100644 --- a/src/func.rs +++ b/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( - f: impl 'a + FnOnce(A, B) -> C, fa: Self::F, fb: Self::F, + f: impl 'a + FnOnce(A, B) -> C, ) -> Self::F; } @@ -112,7 +112,7 @@ pub trait Applicative<'a>: /// Equivalent of Haskell's `<*`. fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { - 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, f: impl 'a + FnOnce(A, B) -> Self::F, ) -> Self::F { - Self::join(Self::la2(f, fa, fb)) + Self::join(Self::la2(fa, fb, f)) } } diff --git a/src/func/derivations.rs b/src/func/derivations.rs index 58724ec..f29425f 100644 --- a/src/func/derivations.rs +++ b/src/func/derivations.rs @@ -33,7 +33,7 @@ pub trait ApplicativeSeqViaLA2<'a>: ApplicativeLA2<'a> { ff: Self::F B>, fa: Self::F, ) -> Self::F { - 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((fa, fb): (Self::F, Self::F)) -> Self::F<(A, B)> { - Self::la2(|a, b| (a, b), fa, fb) + Self::la2(fa, fb, |a, b| (a, b)) } } diff --git a/src/func/instances/composition.rs b/src/func/instances/composition.rs index 7279cc4..b088d43 100644 --- a/src/func/instances/composition.rs +++ b/src/func/instances/composition.rs @@ -39,7 +39,7 @@ impl<'a, U: ApplicativeLA2<'a>, V: ApplicativeSeq<'a>> ApplicativeSeq<'a> for CompositionInstance { fn seq(ff: Self::F B>, fa: Self::F) -> Self::F { - 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 { fn la2( - f: impl 'a + FnOnce(A, B) -> C, fa: Self::F, fb: Self::F, + f: impl 'a + FnOnce(A, B) -> C, ) -> Self::F { - 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 { fn discard_first(fa: Self::F, fb: Self::F) -> Self::F { - U::la2(|ua, ub| V::discard_first(ua, ub), fa, fb) + U::la2(fa, fb, V::discard_first) } fn discard_second(fa: Self::F, fb: Self::F) -> Self::F { - U::la2(|ua, ub| V::discard_second(ua, ub), fa, fb) + U::la2(fa, fb, V::discard_second) } } diff --git a/src/func/instances/effect.rs b/src/func/instances/effect.rs index 70b1857..3ec6c03 100644 --- a/src/func/instances/effect.rs +++ b/src/func/instances/effect.rs @@ -82,9 +82,9 @@ impl<'a, E: 'a + Effect> ApplicativeSeq<'a> for EffectInstance { impl<'a, E: 'a + Effect> ApplicativeLA2<'a> for EffectInstance { fn la2( - f: impl 'a + FnOnce(A, B) -> C, fa: Self::F, fb: Self::F, + f: impl 'a + FnOnce(A, B) -> C, ) -> Self::F { WithEffect { value: f(fa.value, fb.value), diff --git a/src/func/instances/future.rs b/src/func/instances/future.rs index 7275c7d..359188e 100644 --- a/src/func/instances/future.rs +++ b/src/func/instances/future.rs @@ -52,9 +52,9 @@ impl<'a> ApplicativeSeq<'a> for FutureInstance { impl<'a> ApplicativeLA2<'a> for FutureInstance { fn la2( - f: impl 'a + FnOnce(A, B) -> C, fa: Self::F, fb: Self::F, + f: impl 'a + FnOnce(A, B) -> C, ) -> Self::F { Box::pin(async { let (a, b) = join!(fa, fb); diff --git a/src/func/instances/lazy.rs b/src/func/instances/lazy.rs index 9ef13a0..9c5952c 100644 --- a/src/func/instances/lazy.rs +++ b/src/func/instances/lazy.rs @@ -49,9 +49,9 @@ impl<'a> ApplicativeSeq<'a> for LazyInstance { impl<'a> ApplicativeLA2<'a> for LazyInstance { fn la2( - f: impl 'a + FnOnce(A, B) -> C, fa: Self::F, fb: Self::F, + f: impl 'a + FnOnce(A, B) -> C, ) -> Self::F { Box::new(|| f(fa(), fb())) } diff --git a/src/func/instances/option.rs b/src/func/instances/option.rs index 37f4924..3d72077 100644 --- a/src/func/instances/option.rs +++ b/src/func/instances/option.rs @@ -50,9 +50,9 @@ impl<'a> ApplicativeSeq<'a> for OptionInstance { impl<'a> ApplicativeLA2<'a> for OptionInstance { fn la2( - f: impl 'a + FnOnce(A, B) -> C, fa: Self::F, fb: Self::F, + f: impl 'a + FnOnce(A, B) -> C, ) -> Self::F { Self::pure(f(fa?, fb?)) } diff --git a/src/func/instances/overload.rs b/src/func/instances/overload.rs index 0a2be03..7e28693 100644 --- a/src/func/instances/overload.rs +++ b/src/func/instances/overload.rs @@ -56,11 +56,11 @@ impl<'a, T: ApplicativeLA2<'a>, O: 'a + DeriveApplicative> ApplicativeLA2<'a> for OverloadInstance { fn la2( - f: impl 'a + FnOnce(A, B) -> C, fa: Self::F, fb: Self::F, + f: impl 'a + FnOnce(A, B) -> C, ) -> Self::F { - T::la2(f, fa, fb) + T::la2(fa, fb, f) } } diff --git a/src/func/instances/result.rs b/src/func/instances/result.rs index 7ecf923..dd2a721 100644 --- a/src/func/instances/result.rs +++ b/src/func/instances/result.rs @@ -50,9 +50,9 @@ impl<'a, E: 'a> ApplicativeSeq<'a> for ResultInstance { impl<'a, E: 'a> ApplicativeLA2<'a> for ResultInstance { fn la2( - f: impl 'a + FnOnce(A, B) -> C, fa: Self::F, fb: Self::F, + f: impl 'a + FnOnce(A, B) -> C, ) -> Self::F { Self::pure(f(fa?, fb?)) } diff --git a/src/func/instances/solo.rs b/src/func/instances/solo.rs index 38f97e7..82369d9 100644 --- a/src/func/instances/solo.rs +++ b/src/func/instances/solo.rs @@ -44,9 +44,9 @@ impl<'a> ApplicativeSeq<'a> for SoloInstance { impl<'a> ApplicativeLA2<'a> for SoloInstance { fn la2( - f: impl 'a + FnOnce(A, B) -> C, fa: Self::F, fb: Self::F, + f: impl 'a + FnOnce(A, B) -> C, ) -> Self::F { f(fa, fb) } diff --git a/src/func/instances/stackless.rs b/src/func/instances/stackless.rs index ffceb8a..37b4092 100644 --- a/src/func/instances/stackless.rs +++ b/src/func/instances/stackless.rs @@ -157,9 +157,9 @@ impl<'a> ApplicativeSeq<'a> for StacklessInstance { impl<'a> ApplicativeLA2<'a> for StacklessInstance { fn la2( - f: impl 'a + FnOnce(A, B) -> C, fa: Self::F, fb: Self::F, + f: impl 'a + FnOnce(A, B) -> C, ) -> Self::F { Self::_la2_via_seq(f, fa, fb) } diff --git a/src/func/instances/tryfuture.rs b/src/func/instances/tryfuture.rs index 2f479d7..c2333c5 100644 --- a/src/func/instances/tryfuture.rs +++ b/src/func/instances/tryfuture.rs @@ -51,9 +51,9 @@ impl<'a, E: 'a> ApplicativeSeq<'a> for TryFutureInstance { impl<'a, E: 'a> ApplicativeLA2<'a> for TryFutureInstance { fn la2( - f: impl 'a + FnOnce(A, B) -> C, fa: Self::F, fb: Self::F, + f: impl 'a + FnOnce(A, B) -> C, ) -> Self::F { Box::pin(async { let (a, b) = try_join!(fa, fb)?; diff --git a/src/func/tests.rs b/src/func/tests.rs index f30e77d..2f17a31 100644 --- a/src/func/tests.rs +++ b/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), ) }