From 6811d8193210cf6ad2839e50d14683d5f9a2d82a Mon Sep 17 00:00:00 2001
From: timofey <tim@ongoteam.yaconnect.com>
Date: Thu, 25 May 2023 18:15:12 +0000
Subject: [PATCH] regularise `speculative` naming

---
 src/func/speculative.rs | 50 ++++++++++++++++++++---------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/src/func/speculative.rs b/src/func/speculative.rs
index cafe044..2b0c9ef 100644
--- a/src/func/speculative.rs
+++ b/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>(
-        a: Result<A, E0>,
-        wb: Result<WrapE<'a, B, E0, Self>, E1>,
+    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>,
     ) -> WrapE<'a, (A, B), Result<E0, E1>, Self>
     where
         Self: 'a,
     {
-        match wb {
-            Ok(wb) => match a {
+        match rwb {
+            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>(
-        a: Result<A, E0>,
-        fwb: Fwa<'a, B, E0, E1, Self>,
+    fn _speculative_ra_frwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+        ra: Result<A, E0>,
+        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::unstuff(Self::_speculative_a_wb(a, wb))
+        Self::stuff(<Self::T as Monad>::bind(frwb, |rwb| {
+            Self::unstuff(Self::_speculative_ra_rwb(ra, rwb))
         }))
     }
 
-    fn _speculative_fa_wb<'a, A: 'a, B: 'a, E0: 'a>(
-        fa: Wrap<'a, Result<A, E0>, Self::T>,
+    fn _speculative_fra_wb<'a, A: 'a, B: 'a, E0: 'a>(
+        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::B(fa, Ok(wb)) => {
-                            Self::map_err(Self::_speculative_fa_wb(fa, wb), Ok)
+                        Selected::A(ra, frwb) => Self::_speculative_ra_frwb(ra, frwb),
+                        Selected::B(fra, Ok(wb)) => {
+                            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>(
-        fwa: Fwa<'a, A, E0, E1, Self>,
+    fn _speculative_frwa_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
+        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),