fmap reorder

src/flow/binary.rs

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

src/flow/speculative.rs

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

src/flow/traversible/unbalanced.rs

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

src/func.rs

@@ -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`.

src/func/applicative_select.rs

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

src/func/controlflow.rs

@@ -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(
+        T::fmap(fstate, move |state| match state {
-            move |state| match state {
             ControlFlow::Continue(next_a) => {
                 ControlFlow::Continue(BindableMut::new(next_a, self.1))
             }
             ControlFlow::Break(b) => ControlFlow::Break(b),
-            },
+        })
-            fstate,
-        )
     }
 }
 

src/func/derivations.rs

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

src/func/instances/composition.rs

@@ -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> {
+    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> {
-        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(
+        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> {
     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(
+        U::fmap(fstate, |ustate| match V::unstuff(ustate) {
-            |ustate| match V::unstuff(ustate) {
             ControlFlow::Continue(next_f) => ControlFlow::Continue(Self(next_f)),
             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>
 {
     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)
     }
 }

src/func/instances/effect.rs

@@ -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(
+        T::fmap(fa.value, |a| WithEffect {
-            |a| WithEffect {
             value: a,
             effect: fa.effect,
-            },
+        })
-            fa.value,
-        )
     }
 }

src/func/instances/future.rs

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

src/func/instances/lazy.rs

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

src/func/instances/option.rs

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

src/func/instances/overload.rs

@@ -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> {
+    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> {
@@ -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(
+        T::fmap(self.0.next(), |state| match state {
-            |state| match state {
             ControlFlow::Continue(next_f) => ControlFlow::Continue(Self::new(next_f)),
             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>;
 
     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),
         })

src/func/instances/result.rs

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

src/func/instances/solo.rs

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

src/func/instances/stackless.rs

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

src/func/instances/tryfuture.rs

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

src/func/tests.rs

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

src/rcore/resolver_origin.rs

@@ -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(
+    Ctx::T::fmap(resolution, move |resolved| {
-        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,
-    )
 }
 
 impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Origin<'a, Ctx> for ResolverOrigin<'a, Ctx, F> {

src/rstd/cast.rs

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

src/rstd/collections/avl/binary.rs

@@ -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(
+        <Ctx::T as Functor>::fmap(self.node.resolve(), move |resolution| {
-            move |resolution| {
             let node = resolution?;
             node.matches_height(parent_height)
                 .map_err(ResolutionError::Parse)?;
             Ok(node)
-            },
+        })
-            self.node.resolve(),
-        )
     }
 }
 

src/rstd/collections/avl/bounds.rs

@@ -248,8 +248,7 @@ 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(
+        <Ctx::T as Functor>::fmap(self.reference.resolve(), move |resolution| {
-            move |resolution| {
             let node = resolution
                 .map_err(|err| match err {
                     ResolutionError::Lookup(lookup) => ResolutionError::Lookup(lookup),
@@ -274,9 +273,7 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> BoundReference<'a, Ctx, A> {
                 key: node.key,
                 bounds,
             })
-            },
+        })
-            self.reference.resolve(),
-        )
     }
 
     pub fn equal(lhs: &Self, rhs: &Self, comparator: &impl Comparator<A>) -> bool {

src/rstd/collections/rbtree/subset.rs

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

src/rstd/collections/stack.rs

@@ -157,8 +157,7 @@ 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(
+            Nullable::NotNull(point) => Ctx::T::fmap(point.resolve(), |resolved| {
-                |resolved| {
                 let node = match resolved {
                     Ok(node) => node,
                     Err(error) => {
@@ -167,9 +166,7 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> ExtStack<'a, Ctx, A> for Sta
                 };
                 vec.push(node.element.clone());
                 ControlFlow::Continue((vec, node.rest.clone()))
-                },
+            }),
-                point.resolve(),
-            ),
         })
     }
 }

src/rstd/tracing/traceable.rs

@@ -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(
+        TracedInstance::fmap(self.resolver.clone().resolve(address), |resolved| {
-            |resolved| {
             let (src, resolver) = resolved?;
             let delayed: Rc<dyn Resolver<'a, Ctx>> = Rc::new(TracedResolver { resolver });
             Ok((src, delayed))
-            },
+        })
-            self.resolver.clone().resolve(address),
-        )
         .after_resolution()
     }
 }

src/rstd/wrapped_origin.rs

@@ -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(
+    Ctx::T::fmap(resolve(), move |resolved| match resolved {
-        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)) => Err(ResolutionError::Lookup(lookup_error)),
-                Err(ResolutionError::Lookup(lookup_error))
+    })
-            }
-        },
-        resolve(),
-    )
 }
 
 struct WrappedOrigin<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> {

src/testing/counted.rs

@@ -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(
+        CountedInstance::fmap(self.resolver.clone().resolve(address), |resolved| {
-            |resolved| {
             let (src, resolver) = resolved?;
             let delayed: Rc<dyn Resolver<'a, TestContextCounted>> =
                 Rc::new(CountedResolver { resolver });
             Ok((src, delayed))
-            },
+        })
-            self.resolver.clone().resolve(address),
-        )
         .add(1)
     }
 }

src/testing/inject.rs

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