split speculative methods

src/func/speculative.rs

@@ -6,6 +6,29 @@ type Frwa<'a, A, E0, E1, Fallible> =
 type Wwa<'a, A, E0, E1, Fallible> = WrapE<'a, WrapE<'a, A, E0, Fallible>, E1, Fallible>;
 
 pub trait SpeculativeFail: MonadFailAny {
+    fn _speculative_a_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+        a: A,
+        wb: WrapE<'a, B, E0, Self>,
+    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
+    where
+        Self: 'a,
+    {
+        Self::map_err(<Self::W<E0> as Functor>::fmap(|b| (a, b), wb), Ok)
+    }
+
+    fn _speculative_ra_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+        ra: Result<A, E0>,
+        wb: WrapE<'a, B, E0, Self>,
+    ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
+    where
+        Self: 'a,
+    {
+        match ra {
+            Ok(a) => Self::_speculative_a_wb(a, wb),
+            Err(e0) => Self::fail(Ok(e0)),
+        }
+    }
+
     fn _speculative_ra_rwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
         ra: Result<A, E0>,
         rwb: Result<WrapE<'a, B, E0, Self>, E1>,
@@ -14,10 +37,7 @@ pub trait SpeculativeFail: MonadFailAny {
         Self: 'a,
     {
         match rwb {
-            Ok(wb) => match ra {
+            Ok(wb) => Self::_speculative_ra_wb(ra, wb),
-                Ok(a) => Self::map_err(<Self::W<E0> as Functor>::fmap(|b| (a, b), wb), Ok),
-                Err(e0) => Self::fail(Ok(e0)),
-            },
             Err(e1) => Self::fail(Err(e1)),
         }
     }