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

fmap reorder

Browse Source
This commit is contained in:
AF 2023-05-30 00:09:38 +00:00
parent 4794dd1d17
commit 4352f4aa30
28 changed files with 151 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/flow/binary.rs
View File

@ -90,13 +90,13 @@ pub trait BinaryTreesMutable<'a>: BinaryTrees<'a> {
match self.comparator().pick_smaller(&key, &k) {
Comparison::L => {
<Self::T as Monad>::bind(self.clone().split_key(tl, key), move |(tll, tlr)| {
<Self::T as Functor>::fmap(|t| (tll, t), self.join_key_tree(tlr, k, tr))
<Self::T as Functor>::fmap(self.join_key_tree(tlr, k, tr), |t| (tll, t))
})
}
Comparison::E => <Self::T as Pure>::pure((tl, tr)),
Comparison::R => {
<Self::T as Monad>::bind(self.clone().split_key(tr, key), move |(trl, trr)| {
<Self::T as Functor>::fmap(|t| (t, trr), self.join_key_tree(tl, k, trl))
<Self::T as Functor>::fmap(self.join_key_tree(tl, k, trl), |t| (t, trr))
})
}
}

8
src/flow/speculative.rs
View File

@ -10,7 +10,7 @@ trait SpeculativeFailImpl<'a>: MonadFailAny<'a> {
a: A,
wb: WrapE<'a, B, E0, Self>,
) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
Self::map_err(<Self::W<E0> as Functor>::fmap(|b| (a, b), wb), Ok)
Self::map_err(<Self::W<E0> as Functor>::fmap(wb, |b| (a, b)), Ok)
}
fn _speculative_ra_wb<A: 'a, B: 'a, E0: 'a, E1: 'a>(
@ -55,7 +55,6 @@ trait SpeculativeFailImpl<'a>: MonadFailAny<'a> {
) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
Self::stuff(<<Self as MonadFailAny>::T as Monad>::join(
<<Self as MonadFailAny>::T as Functor>::fmap(
Self::unstuff,
Self::T::select_map(Self::unstuff(wa), frwb, |selected| match selected {
Selected::A(ra, frwb) => Self::_speculative_ra_frwb(ra, frwb),
Selected::B(fra, Ok(wb)) => {
@ -63,6 +62,7 @@ trait SpeculativeFailImpl<'a>: MonadFailAny<'a> {
}
Selected::B(_, Err(e1)) => Self::fail(Err(e1)),
}),
Self::unstuff,
),
))
}
@ -72,8 +72,8 @@ trait SpeculativeFailImpl<'a>: MonadFailAny<'a> {
wb: WrapE<'a, B, E0, Self>,
) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
<Self::W<Result<E0, E1>> as Functor>::fmap(
|(b, a)| (a, b),
Self::_speculative_wa_frwb(wb, frwa),
|(b, a)| (a, b),
)
}
@ -82,7 +82,6 @@ trait SpeculativeFailImpl<'a>: MonadFailAny<'a> {
wwb: Wwa<'a, B, E0, E1, Self>,
) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
Self::stuff(<Self::T as Monad>::join(<Self::T as Functor>::fmap(
Self::unstuff,
Self::T::select_map(
Self::unstuff(wwa),
Self::unstuff(wwb),
@ -93,6 +92,7 @@ trait SpeculativeFailImpl<'a>: MonadFailAny<'a> {
Selected::B(_, Err(e1)) => Self::fail(Err(e1)),
},
),
Self::unstuff,
)))
}
}

7
src/flow/traversible/unbalanced.rs
View File

@ -94,10 +94,9 @@ impl<'a, T: Monad<'a>, A: 'a> TraversibleBinaryReference<'a, T, A, UnbalancedDat
for UnbalancedReference<'a, T, A>
{
fn resolve(&self) -> Wrap<'a, Rc<dyn TraversibleBinaryNode<'a, T, A, UnbalancedData>>, T> {
<T as Functor>::fmap(
|rc| rc as Rc<dyn TraversibleBinaryNode<'a, T, A, UnbalancedData>>,
self.0(),
)
<T as Functor>::fmap(self.0(), |rc| {
rc as Rc<dyn TraversibleBinaryNode<'a, T, A, UnbalancedData>>
})
}
fn data(&self) -> UnbalancedData {

4
src/func.rs
View File

@ -57,11 +57,11 @@ pub trait Functor<'a>: WeakFunctor<'a> {
/// Equivalent or Haskell's `fmap`.
/// Due to Rust limitations, it's not a `function->function` conversion.
/// For that see [`derivations::fmap`].
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B>;
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B>;
/// Equivalent of Haskell's `$>`/`<$`.
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
Self::fmap(|_| b, fa)
Self::fmap(fa, |_| b)
}
/// Equivalent of Haskell's `void`.

4
src/func/applicative_select.rs
View File

@ -11,7 +11,7 @@ pub type SelectedWrapped<'a, A, B, T> = Wrap<'a, Selected<'a, A, B, T>, T>;
/// Part of [`Applicative`] responsible for choosing the first value.
pub trait ApplicativeSelect<'a>: Functor<'a> {
fn select<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> SelectedWrapped<'a, A, B, Self> {
Self::fmap(|a| Selected::A(a, fb), fa)
Self::fmap(fa, |a| Selected::A(a, fb))
}
}
@ -22,7 +22,7 @@ pub trait ApplicativeSelectExt<'a>: ApplicativeSelect<'a> {
fb: Self::F<B>,
f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C,
) -> Self::F<C> {
Self::fmap(f, Self::select(fa, fb))
Self::fmap(Self::select(fa, fb), f)
}
}

17
src/func/controlflow.rs
View File

@ -11,7 +11,7 @@ impl<C> WeakFunctorAny for ControlFlowInstance<C> {
}
impl<'a, C: 'a> Functor<'a> for ControlFlowInstance<C> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
match fa {
ControlFlow::Continue(c) => ControlFlow::Continue(c),
ControlFlow::Break(a) => ControlFlow::Break(f(a)),
@ -43,15 +43,12 @@ impl<'a, T: ?Sized + Functor<'a>, A: 'a, B: 'a, F: 'a + FnMut(A) -> T::F<Control
fn next(mut self) -> IterativeWrapped<'a, Self> {
let fstate = self.1(self.0);
T::fmap(
move |state| match state {
ControlFlow::Continue(next_a) => {
ControlFlow::Continue(BindableMut::new(next_a, self.1))
}
ControlFlow::Break(b) => ControlFlow::Break(b),
},
fstate,
)
T::fmap(fstate, move |state| match state {
ControlFlow::Continue(next_a) => {
ControlFlow::Continue(BindableMut::new(next_a, self.1))
}
ControlFlow::Break(b) => ControlFlow::Break(b),
})
}
}

4
src/func/derivations.rs
View File

@ -6,7 +6,7 @@ use super::*;
pub fn fmap<'a, T: Functor<'a>, A: 'a, B: 'a>(
f: impl 'a + FnOnce(A) -> B,
) -> impl FnOnce(Wrap<'a, A, T>) -> Wrap<'a, B, T> {
move |fa| T::fmap(f, fa)
move |fa| T::fmap(fa, f)
}
/// Equivalent of Haskell's `fmap`. `function-function` equivalent of [Monad::bind].
@ -22,7 +22,7 @@ pub trait ApplicativeLA2ViaSeq<'a>: ApplicativeSeq<'a> {
fa: Self::F<A>,
fb: Self::F<B>,
) -> Self::F<C> {
Self::seq(Self::fmap(|a| |b| f(a, b), fa), fb)
Self::seq(Self::fmap(fa, |a| |b| f(a, b)), fb)
}
}

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

@ -15,16 +15,16 @@ impl<'a, U: WeakFunctor<'a>, V: WeakFunctor<'a>> WeakFunctor<'a> for Composition
}
impl<'a, U: Functor<'a>, V: Functor<'a>> Functor<'a> for CompositionInstance<U, V> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
U::fmap(|ua| V::fmap(f, ua), fa)
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
U::fmap(fa, |ua| V::fmap(ua, f))
}
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
U::fmap(|ua| V::replace(ua, b), fa)
U::fmap(fa, |ua| V::replace(ua, b))
}
fn void<A: 'a>(fa: Self::F<A>) -> Self::F<()> {
U::fmap(|ua| V::void(ua), fa)
U::fmap(fa, |ua| V::void(ua))
}
}
@ -59,7 +59,7 @@ impl<'a, U: ApplicativeTuple<'a>, V: ApplicativeTuple<'a>> ApplicativeTuple<'a>
for CompositionInstance<U, V>
{
fn tuple<A: 'a, B: 'a>(fab: (Self::F<A>, Self::F<B>)) -> Self::F<(A, B)> {
U::fmap(V::tuple, U::tuple(fab))
U::fmap(U::tuple(fab), V::tuple)
}
}
@ -68,13 +68,10 @@ impl<'a, U: ApplicativeSelect<'a>, V: Functor<'a>> ApplicativeSelect<'a>
for CompositionInstance<U, V>
{
fn select<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> SelectedWrapped<'a, A, B, Self> {
U::fmap(
|selected| match selected {
Selected::A(ua, fb) => V::fmap(|a| Selected::A(a, fb), ua),
Selected::B(fa, ub) => V::fmap(|b| Selected::B(fa, b), ub),
},
U::select(fa, fb),
)
U::fmap(U::select(fa, fb), |selected| match selected {
Selected::A(ua, fb) => V::fmap(ua, |a| Selected::A(a, fb)),
Selected::B(fa, ub) => V::fmap(ub, |b| Selected::B(fa, b)),
})
}
}
@ -90,7 +87,7 @@ impl<'a, U: Applicative<'a>, V: Applicative<'a>> Applicative<'a> for Composition
impl<'a, U: Monad<'a>, V: Monad<'a> + LocalFunctor<'a>> Monad<'a> for CompositionInstance<U, V> {
fn bind<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> Self::F<B>) -> Self::F<B> {
U::bind(fa, |ua| U::fmap(V::join, V::stuff::<_, U>(V::fmap(f, ua))))
U::bind(fa, |ua| U::fmap(V::stuff::<_, U>(V::fmap(ua, f)), V::join))
}
fn iterate<B: 'a>(f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B> {
@ -105,7 +102,7 @@ impl<'a, U: Monad<'a>, V: Monad<'a> + LocalFunctor<'a>> Monad<'a> for Compositio
/// U V A
/// ```
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<A> {
U::join(U::fmap(|ufa| U::fmap(V::join, V::stuff::<_, U>(ufa)), ffa))
U::join(U::fmap(ffa, |ufa| U::fmap(V::stuff::<_, U>(ufa), V::join)))
}
}
@ -123,13 +120,10 @@ impl<
fn next(self) -> IterativeWrapped<'a, Self> {
let fstate = self.0.next();
U::fmap(
|ustate| match V::unstuff(ustate) {
ControlFlow::Continue(next_f) => ControlFlow::Continue(Self(next_f)),
ControlFlow::Break(b) => ControlFlow::Break(b),
},
fstate,
)
U::fmap(fstate, |ustate| match V::unstuff(ustate) {
ControlFlow::Continue(next_f) => ControlFlow::Continue(Self(next_f)),
ControlFlow::Break(b) => ControlFlow::Break(b),
})
}
}
@ -146,11 +140,11 @@ impl<'a, U: LocalFunctor<'a> + Functor<'a>, V: LocalFunctor<'a>> LocalFunctor<'a
for CompositionInstance<U, V>
{
fn unstuff<A: 'a, B: 'a>(state: Self::F<ControlFlow<B, A>>) -> ControlFlow<Self::F<B>, A> {
U::unstuff(U::fmap(V::unstuff, state))
U::unstuff(U::fmap(state, V::unstuff))
}
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
U::stuff::<_, T>(U::fmap(V::stuff::<_, T>, fa))
U::stuff::<_, T>(U::fmap(fa, V::stuff::<_, T>))
}
}
@ -160,10 +154,10 @@ impl<'a, U: SharedFunctor<'a> + Functor<'a>, V: SharedFunctor<'a>> SharedFunctor
type Shared<A: 'a + Clone> = U::Shared<V::Shared<A>>;
fn share<A: 'a + Clone>(fa: Self::F<A>) -> Self::Shared<A> {
U::share(U::fmap(V::share, fa))
U::share(U::fmap(fa, V::share))
}
fn unshare<A: 'a + Clone>(sa: Self::Shared<A>) -> Self::F<A> {
U::fmap(V::unshare, U::unshare(sa))
U::fmap(U::unshare(sa), V::unshare)
}
}

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

@ -46,7 +46,7 @@ impl<E> WeakFunctorAny for EffectInstance<E> {
}
impl<'a, E: 'a> Functor<'a> for EffectInstance<E> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
WithEffect {
value: f(fa.value),
effect: fa.effect,
@ -146,12 +146,9 @@ impl<'a, E: 'a + Effect> Monad<'a> for EffectInstance<E> {
impl<'a, E: 'a> LocalFunctor<'a> for EffectInstance<E> {
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
T::fmap(
|a| WithEffect {
value: a,
effect: fa.effect,
},
fa.value,
)
T::fmap(fa.value, |a| WithEffect {
value: a,
effect: fa.effect,
})
}
}

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

@ -23,7 +23,7 @@ impl WeakFunctorAny for FutureInstance {
}
impl<'a> Functor<'a> for FutureInstance {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
Box::pin(async { f(fa.await) })
}

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

@ -20,7 +20,7 @@ impl WeakFunctorAny for LazyInstance {
}
impl<'a> Functor<'a> for LazyInstance {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
Box::new(|| f(fa()))
}

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

@ -21,7 +21,7 @@ impl WeakFunctorAny for OptionInstance {
}
impl<'a> Functor<'a> for OptionInstance {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
fa.map(f)
}
@ -108,7 +108,7 @@ impl<'a> LocalFunctor<'a> for OptionInstance {
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
match fa {
Some(ua) => T::fmap(Some, ua),
Some(ua) => T::fmap(ua, Some),
None => T::pure(None),
}
}
@ -145,12 +145,12 @@ mod option_tests {
#[test]
fn fmap_f_none_is_none() {
assert_eq!(T::fmap(|_: ()| (), None), None);
assert_eq!(T::fmap(None, |_: ()| ()), None);
}
#[test]
fn fmap_f_some_a_is_some_f_a() {
assert_eq!(T::fmap(|x| x * x, Some(2)), Some(4));
assert_eq!(T::fmap(Some(2), |x| x * x), Some(4));
}
#[test]

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

@ -25,8 +25,8 @@ impl<'a, T: WeakFunctor<'a>, O: 'a + DeriveWeakFunctor> WeakFunctor<'a> for Over
}
impl<'a, T: Functor<'a>, O: 'a + DeriveFunctor> Functor<'a> for OverloadInstance<T, O> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
T::fmap(f, fa)
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
T::fmap(fa, f)
}
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> {
@ -109,13 +109,10 @@ impl<'a, T: Monad<'a>, O: 'a + DeriveMonad, F: Iterative<'a, T = OverloadInstanc
type T = T;
fn next(self) -> IterativeWrapped<'a, Self> {
T::fmap(
|state| match state {
ControlFlow::Continue(next_f) => ControlFlow::Continue(Self::new(next_f)),
ControlFlow::Break(b) => ControlFlow::Break(b),
},
self.0.next(),
)
T::fmap(self.0.next(), |state| match state {
ControlFlow::Continue(next_f) => ControlFlow::Continue(Self::new(next_f)),
ControlFlow::Break(b) => ControlFlow::Break(b),
})
}
}
@ -152,7 +149,7 @@ impl<'a, Ex: 'a, Fallible: MonadFailAny<'a>> MonadFailAny<'a> for DeriveFailAny<
type T = Fallible::W<Ex>;
fn unstuff<A: 'a, E: 'a>(wa: WrapE<'a, A, E, Self>) -> Wrap<'a, Result<A, E>, Self::T> {
Fallible::bind_err(<Self::W<E> as Functor>::fmap(Ok, wa), |err| match err {
Fallible::bind_err(<Self::W<E> as Functor>::fmap(wa, Ok), |err| match err {
Ok(e) => Fallible::pure(Err(e)),
Err(ex) => Fallible::fail(ex),
})

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

@ -21,7 +21,7 @@ impl<E> WeakFunctorAny for ResultInstance<E> {
}
impl<'a, E: 'a> Functor<'a> for ResultInstance<E> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
fa.map(f)
}
@ -108,7 +108,7 @@ impl<'a, E: 'a> LocalFunctor<'a> for ResultInstance<E> {
fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
match fa {
Ok(ua) => T::fmap(Ok, ua),
Ok(ua) => T::fmap(ua, Ok),
Err(e) => T::pure(Err(e)),
}
}
@ -199,7 +199,7 @@ impl<'a, T: Monad<'a>> MonadFailAny<'a> for ResultFailOver<T> {
wa: WrapE<'a, A, E0, Self>,
f: impl 'a + FnOnce(E0) -> E1,
) -> WrapE<'a, A, E1, Self> {
T::fmap(|a| a.map_err(f), wa)
T::fmap(wa, |a| a.map_err(f))
}
fn bind_err<A: 'a, E0: 'a, E1: 'a>(
@ -222,6 +222,6 @@ impl<'a, T: Monad<'a>> MonadFailAny<'a> for ResultFailOver<T> {
fn rotate_out<A: 'a, E0: 'a, E1: 'a>(
wa: WrapE<'a, Result<A, E1>, E0, Self>,
) -> WrapE<'a, A, Result<E1, E0>, Self> {
T::fmap(<ResultFailAny as MonadFailAny>::rotate_out, wa)
T::fmap(wa, <ResultFailAny as MonadFailAny>::rotate_out)
}
}

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

@ -16,7 +16,7 @@ impl WeakFunctorAny for SoloInstance {
}
impl<'a> Functor<'a> for SoloInstance {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
f(fa)
}

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

@ -126,7 +126,7 @@ impl WeakFunctorAny for StacklessInstance {
}
impl<'a> Functor<'a> for StacklessInstance {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
fa.map(f)
}

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

@ -22,7 +22,7 @@ impl<E> WeakFunctorAny for TryFutureInstance<E> {
}
impl<'a, E: 'a> Functor<'a> for TryFutureInstance<E> {
fn fmap<A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<A>) -> Self::F<B> {
fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
Box::pin(async { Ok(f(fa.await?)) })
}

10
src/func/tests.rs
View File

@ -90,7 +90,7 @@ impl AddAssign<R> for R {
pub fn fmap_respects_identity<'a, T: Functor<'a> + Eqr<'a>, A: 'a + Debug + PartialEq>(
fa0: impl Fn() -> T::F<A>,
) -> R {
T::eqr("identity: fmap id == id", T::fmap(|a| a, fa0()), fa0())
T::eqr("identity: fmap id == id", T::fmap(fa0(), |a| a), fa0())
}
pub fn fmap_respects_composition<
@ -106,8 +106,8 @@ pub fn fmap_respects_composition<
) -> R {
T::eqr(
"composition: fmap (f . g) == fmap f . fmap g",
T::fmap(move |a| f(g(a)), fa0()),
T::fmap(f, T::fmap(g, fa0())),
T::fmap(fa0(), move |a| f(g(a))),
T::fmap(T::fmap(fa0(), g), f),
)
}
@ -203,7 +203,7 @@ pub fn fmap_can_be_expressed_via_seq<
) -> R {
T::eqr(
"fmap via seq: fmap f x = pure f <*> x",
T::fmap(f, fa0()),
T::fmap(fa0(), f),
T::seq(T::pure(f), fa0()),
)
}
@ -289,7 +289,7 @@ pub fn fmap_can_be_expressed_via_bind<
) -> R {
T::eqr(
"fmap via bind: fmap f xs = xs >>= return . f",
T::fmap(f, fa0()),
T::fmap(fa0(), f),
T::bind(fa0(), move |a| T::pure(f(a))),
)
}

19
src/rcore/resolver_origin.rs
View File

@ -28,17 +28,14 @@ fn _resolve_origin<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>>(
origin: Rc<ResolverOrigin<'a, Ctx, A::Fctr>>,
) -> Resolution<'a, Ctx, A> {
let resolution = origin.r_resolver.clone().resolve(origin.r_address);
Ctx::T::fmap(
move |resolved| {
let (src, resolver) = resolved.map_err(ResolutionError::Lookup)?;
let mentionable = origin
.r_factory
.parse_slice(&src, resolver)
.map_err(ResolutionError::Parse)?;
Ok(Rc::new(mentionable))
},
resolution,
)
Ctx::T::fmap(resolution, move |resolved| {
let (src, resolver) = resolved.map_err(ResolutionError::Lookup)?;
let mentionable = origin
.r_factory
.parse_slice(&src, resolver)
.map_err(ResolutionError::Parse)?;
Ok(Rc::new(mentionable))
})
}
impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Origin<'a, Ctx> for ResolverOrigin<'a, Ctx, F> {

4
src/rstd/cast.rs
View File

@ -143,7 +143,7 @@ where
Ok(point) => point,
Err(cast_error) => return cast_error.pure::<Ctx>(),
};
Ctx::T::fmap(cast_resolved, point.resolve())
Ctx::T::fmap(point.resolve(), cast_resolved)
}
}
@ -179,6 +179,7 @@ where
Ctx::LookupError: From<CastError<'a>>,
{
Ctx::T::fmap(
typeless_origin.clone().resolve(),
move |resolved| match resolved {
Ok(typeless_mentionable) => match typeless_mentionable.cast(factory) {
Ok(mentionable) => Ok(Rc::new(mentionable)),
@ -189,7 +190,6 @@ where
ResolutionError::Parse(parse_error) => CastError::Typeless(parse_error).into(),
})),
},
typeless_origin.clone().resolve(),
)
}

15
src/rstd/collections/avl/binary.rs
View File

@ -76,15 +76,12 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> AvlTree<'a, Ctx, A> {
impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> AvlReference<'a, Ctx, A> {
pub fn resolve(&self) -> Resolution<'a, Ctx, AvlNode<'a, Ctx, A>> {
let parent_height = self.parent_height;
<Ctx::T as Functor>::fmap(
move |resolution| {
let node = resolution?;
node.matches_height(parent_height)
.map_err(ResolutionError::Parse)?;
Ok(node)
},
self.node.resolve(),
)
<Ctx::T as Functor>::fmap(self.node.resolve(), move |resolution| {
let node = resolution?;
node.matches_height(parent_height)
.map_err(ResolutionError::Parse)?;
Ok(node)
})
}
}

55
src/rstd/collections/avl/bounds.rs
View File

@ -248,35 +248,32 @@ pub type BrKeySplit<'a, Ctx, A> = BoundResolution<'a, Ctx, A, BoundKeySplit<'a,
impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> BoundReference<'a, Ctx, A> {
pub fn resolve(&self, comparator: Rc<impl 'a + Comparator<A>>) -> BrNode<'a, Ctx, A> {
let bounds = self.bounds.clone();
<Ctx::T as Functor>::fmap(
move |resolution| {
let node = resolution
.map_err(|err| match err {
ResolutionError::Lookup(lookup) => ResolutionError::Lookup(lookup),
ResolutionError::Parse(avl) => ResolutionError::Parse(BoundError::Avl(avl)),
})?
.as_ref()
.clone();
let (bl, br) = bounds
.clone()
.split(&node.key, comparator.as_ref())
.map_err(BoundError::Bounds)
.map_err(ResolutionError::Parse)?;
Ok(BoundNode {
l: BoundTree {
tree: node.l,
bounds: bl,
},
r: BoundTree {
tree: node.r,
bounds: br,
},
key: node.key,
bounds,
})
},
self.reference.resolve(),
)
<Ctx::T as Functor>::fmap(self.reference.resolve(), move |resolution| {
let node = resolution
.map_err(|err| match err {
ResolutionError::Lookup(lookup) => ResolutionError::Lookup(lookup),
ResolutionError::Parse(avl) => ResolutionError::Parse(BoundError::Avl(avl)),
})?
.as_ref()
.clone();
let (bl, br) = bounds
.clone()
.split(&node.key, comparator.as_ref())
.map_err(BoundError::Bounds)
.map_err(ResolutionError::Parse)?;
Ok(BoundNode {
l: BoundTree {
tree: node.l,
bounds: bl,
},
r: BoundTree {
tree: node.r,
bounds: br,
},
key: node.key,
bounds,
})
})
}
pub fn equal(lhs: &Self, rhs: &Self, comparator: &impl Comparator<A>) -> bool {

21
src/rstd/collections/rbtree/subset.rs
View File

@ -94,10 +94,9 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>>
Rc<dyn TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData>>,
SubsetMonad<'a, Ctx, A>,
> {
<SubsetMonad<'a, Ctx, A> as Functor>::fmap(
|resolved| resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>,
Ctx::stuff(self.resolve()),
)
<SubsetMonad<'a, Ctx, A> as Functor>::fmap(Ctx::stuff(self.resolve()), |resolved| {
resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>
})
}
fn data(&self) -> RefData {
@ -116,10 +115,9 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>>
Rc<dyn TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData>>,
SubsetMonad<'a, Ctx, A>,
> {
<SubsetMonad<'a, Ctx, A> as Functor>::fmap(
|resolved| resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>,
Ctx::stuff(self.resolve()),
)
<SubsetMonad<'a, Ctx, A> as Functor>::fmap(Ctx::stuff(self.resolve()), |resolved| {
resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>
})
}
fn data(&self) -> RefData {
@ -138,10 +136,9 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>>
Rc<dyn TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData>>,
SubsetMonad<'a, Ctx, A>,
> {
<SubsetMonad<'a, Ctx, A> as Functor>::fmap(
|resolved| resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>,
Ctx::stuff(self.resolve()),
)
<SubsetMonad<'a, Ctx, A> as Functor>::fmap(Ctx::stuff(self.resolve()), |resolved| {
resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>
})
}
fn data(&self) -> RefData {

23
src/rstd/collections/stack.rs
View File

@ -157,19 +157,16 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> ExtStack<'a, Ctx, A> for Sta
fn vec(self) -> StackVecWrapped<'a, Ctx, A> {
Ctx::T::iterate_mut((vec![], self), |(mut vec, stack)| match stack {
Nullable::Null(_) => Ctx::T::pure(ControlFlow::Break(Ok(vec))),
Nullable::NotNull(point) => Ctx::T::fmap(
|resolved| {
let node = match resolved {
Ok(node) => node,
Err(error) => {
return ControlFlow::Break(Err(error));
}
};
vec.push(node.element.clone());
ControlFlow::Continue((vec, node.rest.clone()))
},
point.resolve(),
),
Nullable::NotNull(point) => Ctx::T::fmap(point.resolve(), |resolved| {
let node = match resolved {
Ok(node) => node,
Err(error) => {
return ControlFlow::Break(Err(error));
}
};
vec.push(node.element.clone());
ControlFlow::Continue((vec, node.rest.clone()))
}),
})
}
}

13
src/rstd/tracing/traceable.rs
View File

@ -14,14 +14,11 @@ impl<'a, Ctx: Context<'a, T = TracedInstance>> TracedResolver<'a, Ctx> {
impl<'a, Ctx: Context<'a, T = TracedInstance>> Resolver<'a, Ctx> for TracedResolver<'a, Ctx> {
fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, Ctx> {
TracedInstance::fmap(
|resolved| {
let (src, resolver) = resolved?;
let delayed: Rc<dyn Resolver<'a, Ctx>> = Rc::new(TracedResolver { resolver });
Ok((src, delayed))
},
self.resolver.clone().resolve(address),
)
TracedInstance::fmap(self.resolver.clone().resolve(address), |resolved| {
let (src, resolver) = resolved?;
let delayed: Rc<dyn Resolver<'a, Ctx>> = Rc::new(TracedResolver { resolver });
Ok((src, delayed))
})
.after_resolution()
}
}

19
src/rstd/wrapped_origin.rs
View File

@ -42,18 +42,13 @@ fn map_resolve<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>, B: Mentionable<'a,
map_ok: impl 'a + Fn(Rc<A>) -> B,
map_err: impl 'a + Fn(ParseError<'a, Ctx, A::Fctr>) -> ParseError<'a, Ctx, B::Fctr>,
) -> Resolution<'a, Ctx, B> {
Ctx::T::fmap(
move |resolved| match resolved {
Ok(mentionable) => Ok(Rc::new(map_ok(mentionable))),
Err(ResolutionError::Parse(parse_error)) => {
Err(ResolutionError::Parse(map_err(parse_error)))
}
Err(ResolutionError::Lookup(lookup_error)) => {
Err(ResolutionError::Lookup(lookup_error))
}
},
resolve(),
)
Ctx::T::fmap(resolve(), move |resolved| match resolved {
Ok(mentionable) => Ok(Rc::new(map_ok(mentionable))),
Err(ResolutionError::Parse(parse_error)) => {
Err(ResolutionError::Parse(map_err(parse_error)))
}
Err(ResolutionError::Lookup(lookup_error)) => Err(ResolutionError::Lookup(lookup_error)),
})
}
struct WrappedOrigin<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> {

15
src/testing/counted.rs
View File

@ -67,15 +67,12 @@ impl<'a> CountedResolver<'a> {
impl<'a> Resolver<'a, TestContextCounted> for CountedResolver<'a> {
fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, TestContextCounted> {
CountedInstance::fmap(
|resolved| {
let (src, resolver) = resolved?;
let delayed: Rc<dyn Resolver<'a, TestContextCounted>> =
Rc::new(CountedResolver { resolver });
Ok((src, delayed))
},
self.resolver.clone().resolve(address),
)
CountedInstance::fmap(self.resolver.clone().resolve(address), |resolved| {
let (src, resolver) = resolved?;
let delayed: Rc<dyn Resolver<'a, TestContextCounted>> =
Rc::new(CountedResolver { resolver });
Ok((src, delayed))
})
.add(1)
}
}

2
src/testing/inject.rs
View File

@ -16,6 +16,7 @@ impl<'a, Ctx: Context<'a>, F: Inject<'a, Ctx>> Resolver<'a, Ctx> for InjectedRes
fn resolve(self: Rc<Self>, address: crate::rcore::Address) -> HashResolution<'a, Ctx> {
let inject = self.inject.clone();
<Ctx::T as Functor>::fmap(
self.resolver.clone().resolve(address),
|resolved| match resolved {
Ok((source, resolver)) => Ok((
source,
@ -23,7 +24,6 @@ impl<'a, Ctx: Context<'a>, F: Inject<'a, Ctx>> Resolver<'a, Ctx> for InjectedRes
)),
Err(e) => Err(e),
},
self.resolver.clone().resolve(address),
)
}
}