select_map

src/func.rs

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

src/func/applicative_select.rs

@@ -18,3 +18,18 @@ pub trait ApplicativeSelect: Functor {
         Self::fmap(|a| Selected::A(a, fb), fa)
     }
 }
+
+pub trait ApplicativeSelectExt: ApplicativeSelect {
+    fn select_map<'a, A: 'a, B: 'a, C: '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>
+    where
+        Self: 'a,
+    {
+        Self::fmap(f, Self::select(fa, fb))
+    }
+}
+
+impl<T: ApplicativeSelect> ApplicativeSelectExt for T {}

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