regularise speculative naming

src/func/speculative.rs

@@ -1,20 +1,20 @@
 use super::*;
 
-type Fwa<'a, A, E0, E1, Fallible> =
+type Frwa<'a, A, E0, E1, Fallible> =
     Wrap<'a, Result<WrapE<'a, A, E0, Fallible>, E1>, <Fallible as MonadFailAny>::T>;
 
 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>(
+    fn _speculative_ra_rwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
-        a: Result<A, E0>,
+        ra: Result<A, E0>,
-        wb: Result<WrapE<'a, B, E0, Self>, E1>,
+        rwb: Result<WrapE<'a, B, E0, Self>, E1>,
     ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
     where
         Self: 'a,
     {
-        match wb {
+        match rwb {
-            Ok(wb) => match a {
+            Ok(wb) => match ra {
                 Ok(a) => Self::map_err(<Self::W<E0> as Functor>::fmap(|b| (a, b), wb), Ok),
                 Err(e0) => Self::fail(Ok(e0)),
             },
@@ -22,31 +22,31 @@ pub trait SpeculativeFail: MonadFailAny {
         }
     }
 
-    fn _speculative_a_fwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+    fn _speculative_ra_frwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
-        a: Result<A, E0>,
+        ra: Result<A, E0>,
-        fwb: Fwa<'a, B, E0, E1, Self>,
+        frwb: Frwa<'a, B, E0, E1, Self>,
     ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
     where
         Self: 'a,
     {
-        Self::stuff(<Self::T as Monad>::bind(fwb, |wb| {
+        Self::stuff(<Self::T as Monad>::bind(frwb, |rwb| {
-            Self::unstuff(Self::_speculative_a_wb(a, wb))
+            Self::unstuff(Self::_speculative_ra_rwb(ra, rwb))
         }))
     }
 
-    fn _speculative_fa_wb<'a, A: 'a, B: 'a, E0: 'a>(
+    fn _speculative_fra_wb<'a, A: 'a, B: 'a, E0: 'a>(
-        fa: Wrap<'a, Result<A, E0>, Self::T>,
+        fra: Wrap<'a, Result<A, E0>, Self::T>,
         wb: WrapE<'a, B, E0, Self>,
     ) -> WrapE<'a, (A, B), E0, Self>
     where
         Self: 'a,
     {
-        <Self::W<E0> as ApplicativeTuple>::tuple((Self::stuff(fa), wb))
+        <Self::W<E0> as ApplicativeTuple>::tuple((Self::stuff(fra), wb))
     }
 
-    fn _speculative_wa_fwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+    fn _speculative_wa_frwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
         wa: WrapE<'a, A, E0, Self>,
-        fwb: Fwa<'a, B, E0, E1, Self>,
+        frwb: Frwa<'a, B, E0, E1, Self>,
     ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
     where
         Self: 'a,
@@ -56,21 +56,21 @@ pub trait SpeculativeFail: MonadFailAny {
                 Self::unstuff,
                 Self::T::select_map(
                     |selected| match selected {
-                        Selected::A(a, fwb) => Self::_speculative_a_fwb(a, fwb),
+                        Selected::A(ra, frwb) => Self::_speculative_ra_frwb(ra, frwb),
-                        Selected::B(fa, Ok(wb)) => {
+                        Selected::B(fra, Ok(wb)) => {
-                            Self::map_err(Self::_speculative_fa_wb(fa, wb), Ok)
+                            Self::map_err(Self::_speculative_fra_wb(fra, wb), Ok)
                         }
                         Selected::B(_, Err(e1)) => Self::fail(Err(e1)),
                     },
                     Self::unstuff(wa),
-                    fwb,
+                    frwb,
                 ),
             ),
         ))
     }
 
-    fn _speculative_fwa_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+    fn _speculative_frwa_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
-        fwa: Fwa<'a, A, E0, E1, Self>,
+        frwa: Frwa<'a, A, E0, E1, Self>,
         wb: WrapE<'a, B, E0, Self>,
     ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
     where
@@ -78,7 +78,7 @@ pub trait SpeculativeFail: MonadFailAny {
     {
         <Self::W<Result<E0, E1>> as Functor>::fmap(
             |(b, a)| (a, b),
-            Self::_speculative_wa_fwb(wb, fwa),
+            Self::_speculative_wa_frwb(wb, frwa),
         )
     }
 
@@ -93,9 +93,9 @@ pub trait SpeculativeFail: MonadFailAny {
             Self::unstuff,
             Self::T::select_map(
                 |selected| match selected {
-                    Selected::A(Ok(wa), fwb) => Self::_speculative_wa_fwb(wa, fwb),
+                    Selected::A(Ok(wa), frwb) => Self::_speculative_wa_frwb(wa, frwb),
                     Selected::A(Err(e1), _) => Self::fail(Err(e1)),
-                    Selected::B(fwa, Ok(wb)) => Self::_speculative_fwa_wb(fwa, wb),
+                    Selected::B(frwa, Ok(wb)) => Self::_speculative_frwa_wb(frwa, wb),
                     Selected::B(_, Err(e1)) => Self::fail(Err(e1)),
                 },
                 Self::unstuff(wwa),