PTV/radn-rs
1
1
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

la2 reorder

Browse Source
This commit is contained in:
AF 2023-05-30 00:00:14 +00:00
parent d6231a26a6
commit 4794dd1d17
15 changed files with 44 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/flow/binary.rs
View File

@ -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(
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();
<Self::T as Monad>::bind(ft, move |t| ctx.join_key_tree(tll, kl, t))
};
let ft = {
let ctx = ctx.clone();
<Self::T as Monad>::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();
<Self::T as Monad>::bind(ft, move |t| ctx.join_key_tree(tll, kl, t))
};
let ft = {
let ctx = ctx.clone();
<Self::T as Monad>::bind(ft, move |t| ctx.join_key_tree(t, kr, trr))
};
ft
})
}
fn split_key_empty(

16
src/flow/traversible/algorithms/subset.rs
View File

@ -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(
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>(

6
src/func.rs
View File

@ -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))
}
}

4
src/func/derivations.rs
View File

@ -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))
}
}

10
src/func/instances/composition.rs
View File

@ -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)
}
}

2
src/func/instances/effect.rs
View File

@ -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),

2
src/func/instances/future.rs
View File

@ -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);

2
src/func/instances/lazy.rs
View File

@ -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()))
}

2
src/func/instances/option.rs
View File

@ -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?))
}

4
src/func/instances/overload.rs
View File

@ -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)
}
}

2
src/func/instances/result.rs
View File

@ -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?))
}

2
src/func/instances/solo.rs
View File

@ -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)
}

2
src/func/instances/stackless.rs
View File

@ -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)
}

2
src/func/instances/tryfuture.rs
View File

@ -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)?;

4
src/func/tests.rs
View File

@ -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),
)
}