simplify select

src/func.rs

@@ -23,7 +23,7 @@ pub use std::ops::ControlFlow;
 
 pub use radn_derive::{CovariantFunctor, SharedFunctor};
 
-pub use self::applicative_select::{ApplicativeSelect, Selected};
+pub use self::applicative_select::{ApplicativeSelect, Selected, SelectedWrapped};
 use self::controlflow::{BindableMut, ControlFlowInstance};
 pub use self::controlflow::{Iterative, IterativeWrapped};
 #[cfg(doc)]

src/func/applicative_select.rs

@@ -5,15 +5,16 @@ pub enum Selected<'a, A: 'a, B: 'a, T: ?Sized + 'a + WeakFunctor> {
     B(T::F<'a, A>, B),
 }
 
+pub type SelectedWrapped<'a, A, B, T> = <T as WeakFunctor>::F<'a, Selected<'a, A, B, T>>;
+
 pub trait ApplicativeSelect: Functor {
-    fn select<'a, A: 'a, B: 'a, C: 'a>(
+    fn select<'a, A: 'a, B: 'a>(
-        f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C,
         fa: Self::F<'a, A>,
         fb: Self::F<'a, B>,
-    ) -> Self::F<'a, C>
+    ) -> SelectedWrapped<'a, A, B, Self>
     where
         Self: 'a,
     {
-        Self::fmap(|a| f(Selected::A(a, fb)), fa)
+        Self::fmap(|a| Selected::A(a, fb), fa)
     }
 }

src/func/instances/composition.rs

@@ -73,21 +73,19 @@ impl<U: ApplicativeTuple, V: ApplicativeTuple> ApplicativeTuple for CompositionI
 }
 
 impl<U: ApplicativeSelect, V: Functor> ApplicativeSelect for CompositionInstance<U, V> {
-    fn select<'a, A: 'a, B: 'a, C: 'a>(
+    fn select<'a, A: 'a, B: 'a>(
-        f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C,
         fa: Self::F<'a, A>,
         fb: Self::F<'a, B>,
-    ) -> Self::F<'a, C>
+    ) -> SelectedWrapped<'a, A, B, Self>
     where
         Self: 'a,
     {
-        U::select(
+        U::fmap(
             |selected| match selected {
-                Selected::A(ua, fb) => V::fmap(|a| f(Selected::A(a, fb)), ua),
+                Selected::A(ua, fb) => V::fmap(|a| Selected::A(a, fb), ua),
-                Selected::B(fa, ub) => V::fmap(|b| f(Selected::B(fa, b)), ub),
+                Selected::B(fa, ub) => V::fmap(|b| Selected::B(fa, b), ub),
             },
-            fa,
+            U::select(fa, fb),
-            fb,
         )
     }
 }

src/func/instances/future.rs

@@ -73,18 +73,17 @@ impl ApplicativeTuple for FutureInstance {
 }
 
 impl ApplicativeSelect for FutureInstance {
-    fn select<'a, A: 'a, B: 'a, C: 'a>(
+    fn select<'a, A: 'a, B: 'a>(
-        f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C,
         fa: Self::F<'a, A>,
         fb: Self::F<'a, B>,
-    ) -> Self::F<'a, C>
+    ) -> SelectedWrapped<'a, A, B, Self>
     where
         Self: 'a,
     {
         Box::pin(async {
             match select(fa, fb).await {
-                Either::Left((a, fb)) => f(Selected::A(a, fb)),
+                Either::Left((a, fb)) => Selected::A(a, fb),
-                Either::Right((b, fa)) => f(Selected::B(fa, b)),
+                Either::Right((b, fa)) => Selected::B(fa, b),
             }
         })
     }

src/func/instances/tryfuture.rs

@@ -83,18 +83,17 @@ impl<E> ApplicativeTuple for TryFutureInstance<E> {
 }
 
 impl<E> ApplicativeSelect for TryFutureInstance<E> {
-    fn select<'a, A: 'a, B: 'a, C: 'a>(
+    fn select<'a, A: 'a, B: 'a>(
-        f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C,
         fa: Self::F<'a, A>,
         fb: Self::F<'a, B>,
-    ) -> Self::F<'a, C>
+    ) -> SelectedWrapped<'a, A, B, Self>
     where
         Self: 'a,
     {
         Box::pin(async {
             match try_select(fa, fb).await {
-                Ok(Either::Left((a, fb))) => Ok(f(Selected::A(a, fb))),
+                Ok(Either::Left((a, fb))) => Ok(Selected::A(a, fb)),
-                Ok(Either::Right((b, fa))) => Ok(f(Selected::B(fa, b))),
+                Ok(Either::Right((b, fa))) => Ok(Selected::B(fa, b)),
                 Err(Either::Left((e, _))) => Err(e),
                 Err(Either::Right((e, _))) => Err(e),
             }

src/func/speculative.rs

@@ -54,7 +54,7 @@ pub trait SpeculativeFail: MonadFailAny {
         Self::stuff(<<Self as MonadFailAny>::T as Monad>::join(
             <<Self as MonadFailAny>::T as Functor>::fmap(
                 Self::unstuff,
-                <Self::T as ApplicativeSelect>::select(
+                <Self::T as Functor>::fmap(
                     |selected| match selected {
                         Selected::A(a, fwb) => Self::_speculative_a_fwb(a, fwb),
                         Selected::B(fa, Ok(wb)) => {
@@ -62,8 +62,7 @@ pub trait SpeculativeFail: MonadFailAny {
                         }
                         Selected::B(_, Err(e1)) => Self::fail(Err(e1)),
                     },
-                    Self::unstuff(wa),
+                    <Self::T as ApplicativeSelect>::select(Self::unstuff(wa), fwb),
-                    fwb,
                 ),
             ),
         ))
@@ -91,15 +90,14 @@ pub trait SpeculativeFail: MonadFailAny {
     {
         Self::stuff(<Self::T as Monad>::join(<Self::T as Functor>::fmap(
             Self::unstuff,
-            <Self::T as ApplicativeSelect>::select(
+            <Self::T as Functor>::fmap(
                 |selected| match selected {
                     Selected::A(Ok(wa), fwb) => Self::_speculative_wa_fwb(wa, fwb),
                     Selected::A(Err(e1), _) => Self::fail(Err(e1)),
                     Selected::B(fwa, Ok(wb)) => Self::_speculative_fwa_wb(fwa, wb),
                     Selected::B(_, Err(e1)) => Self::fail(Err(e1)),
                 },
-                Self::unstuff(wwa),
+                <Self::T as ApplicativeSelect>::select(Self::unstuff(wwa), Self::unstuff(wwb)),
-                Self::unstuff(wwb),
             ),
         )))
     }