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) { match self.comparator().pick_smaller(&key, &k) {
Comparison::L => { Comparison::L => {
<Self::T as Monad>::bind(self.clone().split_key(tl, key), move |(tll, tlr)| { <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::E => <Self::T as Pure>::pure((tl, tr)),
Comparison::R => { Comparison::R => {
<Self::T as Monad>::bind(self.clone().split_key(tr, key), move |(trl, trr)| { <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, a: A,
wb: WrapE<'a, B, E0, Self>, wb: WrapE<'a, B, E0, Self>,
) -> WrapE<'a, (A, B), Result<E0, E1>, 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>( 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> { ) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
Self::stuff(<<Self as MonadFailAny>::T as Monad>::join( Self::stuff(<<Self as MonadFailAny>::T as Monad>::join(
<<Self as MonadFailAny>::T as Functor>::fmap( <<Self as MonadFailAny>::T as Functor>::fmap(
Self::unstuff,
Self::T::select_map(Self::unstuff(wa), frwb, |selected| match selected { Self::T::select_map(Self::unstuff(wa), frwb, |selected| match selected {
Selected::A(ra, frwb) => Self::_speculative_ra_frwb(ra, frwb), Selected::A(ra, frwb) => Self::_speculative_ra_frwb(ra, frwb),
Selected::B(fra, Ok(wb)) => { Selected::B(fra, Ok(wb)) => {
@ -63,6 +62,7 @@ trait SpeculativeFailImpl<'a>: MonadFailAny<'a> {
} }
Selected::B(_, Err(e1)) => Self::fail(Err(e1)), 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>, wb: WrapE<'a, B, E0, Self>,
) -> WrapE<'a, (A, B), Result<E0, E1>, Self> { ) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
<Self::W<Result<E0, E1>> as Functor>::fmap( <Self::W<Result<E0, E1>> as Functor>::fmap(
|(b, a)| (a, b),
Self::_speculative_wa_frwb(wb, frwa), 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>, wwb: Wwa<'a, B, E0, E1, Self>,
) -> WrapE<'a, (A, B), Result<E0, E1>, Self> { ) -> WrapE<'a, (A, B), Result<E0, E1>, Self> {
Self::stuff(<Self::T as Monad>::join(<Self::T as Functor>::fmap( Self::stuff(<Self::T as Monad>::join(<Self::T as Functor>::fmap(
Self::unstuff,
Self::T::select_map( Self::T::select_map(
Self::unstuff(wwa), Self::unstuff(wwa),
Self::unstuff(wwb), Self::unstuff(wwb),
@ -93,6 +92,7 @@ trait SpeculativeFailImpl<'a>: MonadFailAny<'a> {
Selected::B(_, Err(e1)) => Self::fail(Err(e1)), 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> for UnbalancedReference<'a, T, A>
{ {
fn resolve(&self) -> Wrap<'a, Rc<dyn TraversibleBinaryNode<'a, T, A, UnbalancedData>>, T> { fn resolve(&self) -> Wrap<'a, Rc<dyn TraversibleBinaryNode<'a, T, A, UnbalancedData>>, T> {
<T as Functor>::fmap( <T as Functor>::fmap(self.0(), |rc| {
|rc| rc as Rc<dyn TraversibleBinaryNode<'a, T, A, UnbalancedData>>, rc as Rc<dyn TraversibleBinaryNode<'a, T, A, UnbalancedData>>
self.0(), })
)
} }
fn data(&self) -> 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`. /// Equivalent or Haskell's `fmap`.
/// Due to Rust limitations, it's not a `function->function` conversion. /// Due to Rust limitations, it's not a `function->function` conversion.
/// For that see [`derivations::fmap`]. /// 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 `$>`/`<$`. /// Equivalent of Haskell's `$>`/`<$`.
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> { 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`. /// 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. /// Part of [`Applicative`] responsible for choosing the first value.
pub trait ApplicativeSelect<'a>: Functor<'a> { 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> { 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>, fb: Self::F<B>,
f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C, f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C,
) -> Self::F<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> { 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 { match fa {
ControlFlow::Continue(c) => ControlFlow::Continue(c), ControlFlow::Continue(c) => ControlFlow::Continue(c),
ControlFlow::Break(a) => ControlFlow::Break(f(a)), 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> { fn next(mut self) -> IterativeWrapped<'a, Self> {
let fstate = self.1(self.0); let fstate = self.1(self.0);
T::fmap( T::fmap(fstate, move |state| match state {
move |state| match state { ControlFlow::Continue(next_a) => {
ControlFlow::Continue(next_a) => { ControlFlow::Continue(BindableMut::new(next_a, self.1))
ControlFlow::Continue(BindableMut::new(next_a, self.1)) }
} ControlFlow::Break(b) => ControlFlow::Break(b),
ControlFlow::Break(b) => ControlFlow::Break(b), })
},
fstate,
)
} }
} }

4
src/func/derivations.rs
View File

@ -6,7 +6,7 @@ use super::*;
pub fn fmap<'a, T: Functor<'a>, A: 'a, B: 'a>( pub fn fmap<'a, T: Functor<'a>, A: 'a, B: 'a>(
f: impl 'a + FnOnce(A) -> B, f: impl 'a + FnOnce(A) -> B,
) -> impl FnOnce(Wrap<'a, A, T>) -> Wrap<'a, B, T> { ) -> 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]. /// 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>, fa: Self::F<A>,
fb: Self::F<B>, fb: Self::F<B>,
) -> Self::F<C> { ) -> 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> { 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> { fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
U::fmap(|ua| V::fmap(f, ua), fa) U::fmap(fa, |ua| V::fmap(ua, f))
} }
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> { 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<()> { 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> for CompositionInstance<U, V>
{ {
fn tuple<A: 'a, B: 'a>(fab: (Self::F<A>, Self::F<B>)) -> Self::F<(A, B)> { 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> for CompositionInstance<U, V>
{ {
fn select<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> SelectedWrapped<'a, A, B, Self> { fn select<A: 'a, B: 'a>(fa: Self::F<A>, fb: Self::F<B>) -> SelectedWrapped<'a, A, B, Self> {
U::fmap( U::fmap(U::select(fa, fb), |selected| match selected {
|selected| match selected { Selected::A(ua, fb) => V::fmap(ua, |a| Selected::A(a, fb)),
Selected::A(ua, fb) => V::fmap(|a| Selected::A(a, fb), ua), Selected::B(fa, ub) => V::fmap(ub, |b| Selected::B(fa, b)),
Selected::B(fa, ub) => V::fmap(|b| Selected::B(fa, b), ub), })
},
U::select(fa, fb),
)
} }
} }
@ -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> { 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> { 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> { 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 /// U V A
/// ``` /// ```
fn join<A: 'a>(ffa: Self::F<Self::F<A>>) -> Self::F<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> { fn next(self) -> IterativeWrapped<'a, Self> {
let fstate = self.0.next(); let fstate = self.0.next();
U::fmap( U::fmap(fstate, |ustate| match V::unstuff(ustate) {
|ustate| match V::unstuff(ustate) { ControlFlow::Continue(next_f) => ControlFlow::Continue(Self(next_f)),
ControlFlow::Continue(next_f) => ControlFlow::Continue(Self(next_f)), ControlFlow::Break(b) => ControlFlow::Break(b),
ControlFlow::Break(b) => ControlFlow::Break(b), })
},
fstate,
)
} }
} }
@ -146,11 +140,11 @@ impl<'a, U: LocalFunctor<'a> + Functor<'a>, V: LocalFunctor<'a>> LocalFunctor<'a
for CompositionInstance<U, V> for CompositionInstance<U, V>
{ {
fn unstuff<A: 'a, B: 'a>(state: Self::F<ControlFlow<B, A>>) -> ControlFlow<Self::F<B>, A> { 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>> { 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>>; type Shared<A: 'a + Clone> = U::Shared<V::Shared<A>>;
fn share<A: 'a + Clone>(fa: Self::F<A>) -> Self::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> { 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> { 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 { WithEffect {
value: f(fa.value), value: f(fa.value),
effect: fa.effect, 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> { 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>> { fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
T::fmap( T::fmap(fa.value, |a| WithEffect {
|a| WithEffect { value: a,
value: a, effect: fa.effect,
effect: fa.effect, })
},
fa.value,
)
} }
} }

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

@ -23,7 +23,7 @@ impl WeakFunctorAny for FutureInstance {
} }
impl<'a> Functor<'a> 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) }) 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 { 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())) 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 { 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) 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>> { fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
match fa { match fa {
Some(ua) => T::fmap(Some, ua), Some(ua) => T::fmap(ua, Some),
None => T::pure(None), None => T::pure(None),
} }
} }
@ -145,12 +145,12 @@ mod option_tests {
#[test] #[test]
fn fmap_f_none_is_none() { fn fmap_f_none_is_none() {
assert_eq!(T::fmap(|_: ()| (), None), None); assert_eq!(T::fmap(None, |_: ()| ()), None);
} }
#[test] #[test]
fn fmap_f_some_a_is_some_f_a() { 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] #[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> { 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> { fn fmap<A: 'a, B: 'a>(fa: Self::F<A>, f: impl 'a + FnOnce(A) -> B) -> Self::F<B> {
T::fmap(f, fa) T::fmap(fa, f)
} }
fn replace<A: 'a, B: 'a>(fa: Self::F<A>, b: B) -> Self::F<B> { 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; type T = T;
fn next(self) -> IterativeWrapped<'a, Self> { fn next(self) -> IterativeWrapped<'a, Self> {
T::fmap( T::fmap(self.0.next(), |state| match state {
|state| match state { ControlFlow::Continue(next_f) => ControlFlow::Continue(Self::new(next_f)),
ControlFlow::Continue(next_f) => ControlFlow::Continue(Self::new(next_f)), ControlFlow::Break(b) => ControlFlow::Break(b),
ControlFlow::Break(b) => ControlFlow::Break(b), })
},
self.0.next(),
)
} }
} }
@ -152,7 +149,7 @@ impl<'a, Ex: 'a, Fallible: MonadFailAny<'a>> MonadFailAny<'a> for DeriveFailAny<
type T = Fallible::W<Ex>; type T = Fallible::W<Ex>;
fn unstuff<A: 'a, E: 'a>(wa: WrapE<'a, A, E, Self>) -> Wrap<'a, Result<A, E>, Self::T> { 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)), Ok(e) => Fallible::pure(Err(e)),
Err(ex) => Fallible::fail(ex), 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> { 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) 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>> { fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>> {
match fa { match fa {
Ok(ua) => T::fmap(Ok, ua), Ok(ua) => T::fmap(ua, Ok),
Err(e) => T::pure(Err(e)), 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>, wa: WrapE<'a, A, E0, Self>,
f: impl 'a + FnOnce(E0) -> E1, f: impl 'a + FnOnce(E0) -> E1,
) -> WrapE<'a, A, E1, Self> { ) -> 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>( 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>( fn rotate_out<A: 'a, E0: 'a, E1: 'a>(
wa: WrapE<'a, Result<A, E1>, E0, Self>, wa: WrapE<'a, Result<A, E1>, E0, Self>,
) -> WrapE<'a, A, Result<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 { 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) f(fa)
} }

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

@ -126,7 +126,7 @@ impl WeakFunctorAny for StacklessInstance {
} }
impl<'a> Functor<'a> 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) 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> { 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?)) }) 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>( pub fn fmap_respects_identity<'a, T: Functor<'a> + Eqr<'a>, A: 'a + Debug + PartialEq>(
fa0: impl Fn() -> T::F<A>, fa0: impl Fn() -> T::F<A>,
) -> R { ) -> 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< pub fn fmap_respects_composition<
@ -106,8 +106,8 @@ pub fn fmap_respects_composition<
) -> R { ) -> R {
T::eqr( T::eqr(
"composition: fmap (f . g) == fmap f . fmap g", "composition: fmap (f . g) == fmap f . fmap g",
T::fmap(move |a| f(g(a)), fa0()), T::fmap(fa0(), move |a| f(g(a))),
T::fmap(f, T::fmap(g, fa0())), T::fmap(T::fmap(fa0(), g), f),
) )
} }
@ -203,7 +203,7 @@ pub fn fmap_can_be_expressed_via_seq<
) -> R { ) -> R {
T::eqr( T::eqr(
"fmap via seq: fmap f x = pure f <*> x", "fmap via seq: fmap f x = pure f <*> x",
T::fmap(f, fa0()), T::fmap(fa0(), f),
T::seq(T::pure(f), fa0()), T::seq(T::pure(f), fa0()),
) )
} }
@ -289,7 +289,7 @@ pub fn fmap_can_be_expressed_via_bind<
) -> R { ) -> R {
T::eqr( T::eqr(
"fmap via bind: fmap f xs = xs >>= return . f", "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))), 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>>, origin: Rc<ResolverOrigin<'a, Ctx, A::Fctr>>,
) -> Resolution<'a, Ctx, A> { ) -> Resolution<'a, Ctx, A> {
let resolution = origin.r_resolver.clone().resolve(origin.r_address); let resolution = origin.r_resolver.clone().resolve(origin.r_address);
Ctx::T::fmap( Ctx::T::fmap(resolution, move |resolved| {
move |resolved| { let (src, resolver) = resolved.map_err(ResolutionError::Lookup)?;
let (src, resolver) = resolved.map_err(ResolutionError::Lookup)?; let mentionable = origin
let mentionable = origin .r_factory
.r_factory .parse_slice(&src, resolver)
.parse_slice(&src, resolver) .map_err(ResolutionError::Parse)?;
.map_err(ResolutionError::Parse)?; Ok(Rc::new(mentionable))
Ok(Rc::new(mentionable)) })
},
resolution,
)
} }
impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Origin<'a, Ctx> for ResolverOrigin<'a, Ctx, F> { 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, Ok(point) => point,
Err(cast_error) => return cast_error.pure::<Ctx>(), 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::LookupError: From<CastError<'a>>,
{ {
Ctx::T::fmap( Ctx::T::fmap(
typeless_origin.clone().resolve(),
move |resolved| match resolved { move |resolved| match resolved {
Ok(typeless_mentionable) => match typeless_mentionable.cast(factory) { Ok(typeless_mentionable) => match typeless_mentionable.cast(factory) {
Ok(mentionable) => Ok(Rc::new(mentionable)), Ok(mentionable) => Ok(Rc::new(mentionable)),
@ -189,7 +190,6 @@ where
ResolutionError::Parse(parse_error) => CastError::Typeless(parse_error).into(), 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> { impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> AvlReference<'a, Ctx, A> {
pub fn resolve(&self) -> Resolution<'a, Ctx, AvlNode<'a, Ctx, A>> { pub fn resolve(&self) -> Resolution<'a, Ctx, AvlNode<'a, Ctx, A>> {
let parent_height = self.parent_height; let parent_height = self.parent_height;
<Ctx::T as Functor>::fmap( <Ctx::T as Functor>::fmap(self.node.resolve(), move |resolution| {
move |resolution| { let node = resolution?;
let node = resolution?; node.matches_height(parent_height)
node.matches_height(parent_height) .map_err(ResolutionError::Parse)?;
.map_err(ResolutionError::Parse)?; Ok(node)
Ok(node) })
},
self.node.resolve(),
)
} }
} }

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> { 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> { pub fn resolve(&self, comparator: Rc<impl 'a + Comparator<A>>) -> BrNode<'a, Ctx, A> {
let bounds = self.bounds.clone(); let bounds = self.bounds.clone();
<Ctx::T as Functor>::fmap( <Ctx::T as Functor>::fmap(self.reference.resolve(), move |resolution| {
move |resolution| { let node = resolution
let node = resolution .map_err(|err| match err {
.map_err(|err| match err { ResolutionError::Lookup(lookup) => ResolutionError::Lookup(lookup),
ResolutionError::Lookup(lookup) => ResolutionError::Lookup(lookup), ResolutionError::Parse(avl) => ResolutionError::Parse(BoundError::Avl(avl)),
ResolutionError::Parse(avl) => ResolutionError::Parse(BoundError::Avl(avl)), })?
})? .as_ref()
.as_ref() .clone();
.clone(); let (bl, br) = bounds
let (bl, br) = bounds .clone()
.clone() .split(&node.key, comparator.as_ref())
.split(&node.key, comparator.as_ref()) .map_err(BoundError::Bounds)
.map_err(BoundError::Bounds) .map_err(ResolutionError::Parse)?;
.map_err(ResolutionError::Parse)?; Ok(BoundNode {
Ok(BoundNode { l: BoundTree {
l: BoundTree { tree: node.l,
tree: node.l, bounds: bl,
bounds: bl, },
}, r: BoundTree {
r: BoundTree { tree: node.r,
tree: node.r, bounds: br,
bounds: br, },
}, key: node.key,
key: node.key, bounds,
bounds, })
}) })
},
self.reference.resolve(),
)
} }
pub fn equal(lhs: &Self, rhs: &Self, comparator: &impl Comparator<A>) -> bool { 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>>, Rc<dyn TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData>>,
SubsetMonad<'a, Ctx, A>, SubsetMonad<'a, Ctx, A>,
> { > {
<SubsetMonad<'a, Ctx, A> as Functor>::fmap( <SubsetMonad<'a, Ctx, A> as Functor>::fmap(Ctx::stuff(self.resolve()), |resolved| {
|resolved| resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>, resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>
Ctx::stuff(self.resolve()), })
)
} }
fn data(&self) -> RefData { 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>>, Rc<dyn TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData>>,
SubsetMonad<'a, Ctx, A>, SubsetMonad<'a, Ctx, A>,
> { > {
<SubsetMonad<'a, Ctx, A> as Functor>::fmap( <SubsetMonad<'a, Ctx, A> as Functor>::fmap(Ctx::stuff(self.resolve()), |resolved| {
|resolved| resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>, resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>
Ctx::stuff(self.resolve()), })
)
} }
fn data(&self) -> RefData { 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>>, Rc<dyn TraversibleBinaryNode<'a, SubsetMonad<'a, Ctx, A>, A, RefData>>,
SubsetMonad<'a, Ctx, A>, SubsetMonad<'a, Ctx, A>,
> { > {
<SubsetMonad<'a, Ctx, A> as Functor>::fmap( <SubsetMonad<'a, Ctx, A> as Functor>::fmap(Ctx::stuff(self.resolve()), |resolved| {
|resolved| resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>, resolved as Rc<dyn TraversibleBinaryNode<'a, _, _, _>>
Ctx::stuff(self.resolve()), })
)
} }
fn data(&self) -> RefData { 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> { fn vec(self) -> StackVecWrapped<'a, Ctx, A> {
Ctx::T::iterate_mut((vec![], self), |(mut vec, stack)| match stack { Ctx::T::iterate_mut((vec![], self), |(mut vec, stack)| match stack {
Nullable::Null(_) => Ctx::T::pure(ControlFlow::Break(Ok(vec))), Nullable::Null(_) => Ctx::T::pure(ControlFlow::Break(Ok(vec))),
Nullable::NotNull(point) => Ctx::T::fmap( Nullable::NotNull(point) => Ctx::T::fmap(point.resolve(), |resolved| {
|resolved| { let node = match resolved {
let node = match resolved { Ok(node) => node,
Ok(node) => node, Err(error) => {
Err(error) => { return ControlFlow::Break(Err(error));
return ControlFlow::Break(Err(error)); }
} };
}; vec.push(node.element.clone());
vec.push(node.element.clone()); ControlFlow::Continue((vec, node.rest.clone()))
ControlFlow::Continue((vec, node.rest.clone())) }),
},
point.resolve(),
),
}) })
} }
} }

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> { impl<'a, Ctx: Context<'a, T = TracedInstance>> Resolver<'a, Ctx> for TracedResolver<'a, Ctx> {
fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, Ctx> { fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, Ctx> {
TracedInstance::fmap( TracedInstance::fmap(self.resolver.clone().resolve(address), |resolved| {
|resolved| { let (src, resolver) = resolved?;
let (src, resolver) = resolved?; let delayed: Rc<dyn Resolver<'a, Ctx>> = Rc::new(TracedResolver { resolver });
let delayed: Rc<dyn Resolver<'a, Ctx>> = Rc::new(TracedResolver { resolver }); Ok((src, delayed))
Ok((src, delayed)) })
},
self.resolver.clone().resolve(address),
)
.after_resolution() .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_ok: impl 'a + Fn(Rc<A>) -> B,
map_err: impl 'a + Fn(ParseError<'a, Ctx, A::Fctr>) -> ParseError<'a, Ctx, B::Fctr>, map_err: impl 'a + Fn(ParseError<'a, Ctx, A::Fctr>) -> ParseError<'a, Ctx, B::Fctr>,
) -> Resolution<'a, Ctx, B> { ) -> Resolution<'a, Ctx, B> {
Ctx::T::fmap( Ctx::T::fmap(resolve(), move |resolved| match resolved {
move |resolved| match resolved { Ok(mentionable) => Ok(Rc::new(map_ok(mentionable))),
Ok(mentionable) => Ok(Rc::new(map_ok(mentionable))), Err(ResolutionError::Parse(parse_error)) => {
Err(ResolutionError::Parse(parse_error)) => { Err(ResolutionError::Parse(map_err(parse_error)))
Err(ResolutionError::Parse(map_err(parse_error))) }
} Err(ResolutionError::Lookup(lookup_error)) => Err(ResolutionError::Lookup(lookup_error)),
Err(ResolutionError::Lookup(lookup_error)) => { })
Err(ResolutionError::Lookup(lookup_error))
}
},
resolve(),
)
} }
struct WrappedOrigin<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> { 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> { impl<'a> Resolver<'a, TestContextCounted> for CountedResolver<'a> {
fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, TestContextCounted> { fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, TestContextCounted> {
CountedInstance::fmap( CountedInstance::fmap(self.resolver.clone().resolve(address), |resolved| {
|resolved| { let (src, resolver) = resolved?;
let (src, resolver) = resolved?; let delayed: Rc<dyn Resolver<'a, TestContextCounted>> =
let delayed: Rc<dyn Resolver<'a, TestContextCounted>> = Rc::new(CountedResolver { resolver });
Rc::new(CountedResolver { resolver }); Ok((src, delayed))
Ok((src, delayed)) })
},
self.resolver.clone().resolve(address),
)
.add(1) .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> { fn resolve(self: Rc<Self>, address: crate::rcore::Address) -> HashResolution<'a, Ctx> {
let inject = self.inject.clone(); let inject = self.inject.clone();
<Ctx::T as Functor>::fmap( <Ctx::T as Functor>::fmap(
self.resolver.clone().resolve(address),
|resolved| match resolved { |resolved| match resolved {
Ok((source, resolver)) => Ok(( Ok((source, resolver)) => Ok((
source, source,
@ -23,7 +24,6 @@ impl<'a, Ctx: Context<'a>, F: Inject<'a, Ctx>> Resolver<'a, Ctx> for InjectedRes
)), )),
Err(e) => Err(e), Err(e) => Err(e),
}, },
self.resolver.clone().resolve(address),
) )
} }
} }