func::fail

src/func.rs

@@ -12,6 +12,7 @@ pub mod context;
 mod controlflow;
 pub mod derivations;
 mod extensions;
+mod fail;
 pub mod instances;
 pub mod shared;
 #[cfg(test)]
@@ -27,6 +28,7 @@ pub use self::applicative_select::{
 use self::controlflow::{BindableMut, ControlFlowInstance};
 pub use self::controlflow::{Iterative, IterativeWrapped};
 pub use self::extensions::{MonadExt, MonadFailAnyExt};
+pub use self::fail::{Fail, MonadFail, MonadFailAny, WrapE};
 #[cfg(doc)]
 use self::instances::stackless::StacklessInstance;
 
@@ -139,19 +141,6 @@ pub trait Monad<'a>: Applicative<'a> {
 
 impl<'a, T: Monad<'a>> MonadExt<'a> for T {}
 
-/// Part of [`MonadFail`] responsible for Haskell's `fail`.
-pub trait Fail<'a, E: 'a>: WeakFunctor<'a> {
-    /// Equivalent of Haskell's `fail`.
-    fn fail<A: 'a>(e: E) -> Self::F<A>;
-}
-
-/// Equivalent of Haskell's `MonadFail`. Auto-implemented for all [`Fail`]`+`[`Monad`].
-///
-/// <https://hackage.haskell.org/package/base-4.18.0.0/docs/Control-Monad.html>
-pub trait MonadFail<'a, E: 'a>: Monad<'a> + Fail<'a, E> {}
-
-impl<'a, E: 'a, T: Monad<'a> + Fail<'a, E>> MonadFail<'a, E> for T {}
-
 /// Represents wrapped results which are instantly available.
 pub trait LocalFunctor<'a>: WeakFunctor<'a> {
     /// Extract iteration state, if successful.
@@ -162,75 +151,3 @@ pub trait LocalFunctor<'a>: WeakFunctor<'a> {
     /// Stuff wrapped result into another functor.
     fn stuff<A: 'a, T: Pure<'a>>(fa: Self::F<T::F<A>>) -> T::F<Self::F<A>>;
 }
-
-/// Represents a (collection of) [Monad]\(s) that can hold any type of error.
-pub trait MonadFailAny<'a>: 'a {
-    /// [`MonadFail`] for a specific error type.
-    type W<E>: MonadFail<'a, E>
-    where
-        E: 'a;
-
-    /// Associated infallible [`Monad`].
-    type T: Monad<'a>;
-
-    fn unstuff<A: 'a, E: 'a>(wa: WrapE<'a, A, E, Self>) -> Wrap<'a, Result<A, E>, Self::T>;
-
-    fn stuff<A: 'a, E: 'a>(fa: Wrap<'a, Result<A, E>, Self::T>) -> WrapE<'a, A, E, Self>;
-
-    /// Equivalent of [`Result::map_err`].
-    fn map_err<A: 'a, E0: 'a, E1: 'a>(
-        wa: WrapE<'a, A, E0, Self>,
-        f: impl 'a + FnOnce(E0) -> E1,
-    ) -> WrapE<'a, A, E1, Self> {
-        Self::bind_err(wa, |e0| Self::fail(f(e0)))
-    }
-
-    /// Equivalent of `catch`/`except`. To inject errors on success, see [`MonadFailAny::bind`].
-    fn bind_err<A: 'a, E0: 'a, E1: 'a>(
-        wa: WrapE<'a, A, E0, Self>,
-        f: impl 'a + FnOnce(E0) -> WrapE<'a, A, E1, Self>,
-    ) -> WrapE<'a, A, E1, Self> {
-        Self::bind(wa, |result| match result {
-            Ok(a) => Self::pure(a),
-            Err(e0) => f(e0),
-        })
-    }
-
-    /// Bind the result, an equivalent of `catch`/`except` with ability to "raise" extra errors
-    /// on success too, unlike [`MonadFailAny::bind_err`].
-    ///
-    /// Note: Reasonably it is expected to lack fail semantics for the underlying result.
-    /// Therefore the default implementation descends into the non-fail monad [`MonadFailAny::T`].
-    fn bind<A: 'a, B: 'a, E0: 'a, E1: 'a>(
-        wa: WrapE<'a, A, E0, Self>,
-        f: impl 'a + FnOnce(Result<A, E0>) -> WrapE<'a, B, E1, Self>,
-    ) -> WrapE<'a, B, E1, Self> {
-        Self::stuff(<Self::T as Monad>::bind(Self::unstuff(wa), |result| {
-            Self::unstuff(f(result))
-        }))
-    }
-
-    /// Equivalent of [`Monad::join`], flattening the errors.
-    ///
-    /// Note: default implementation doesn't depend on [`Monad::join`].
-    fn join<A: 'a, E0: 'a, E1: 'a>(
-        wwa: WrapE<'a, WrapE<'a, A, E0, Self>, E1, Self>,
-    ) -> WrapE<'a, A, Result<E0, E1>, Self> {
-        Self::bind(wwa, |result| match result {
-            Ok(wa) => Self::map_err(wa, Ok),
-            Err(e1) => Self::fail(Err(e1)),
-        })
-    }
-
-    /// Lift the error.
-    fn rotate_out<A: 'a, E0: 'a, E1: 'a>(
-        wa: WrapE<'a, Result<A, E1>, E0, Self>,
-    ) -> WrapE<'a, A, Result<E1, E0>, Self> {
-        <Self::W<Result<E1, E0>> as Monad>::bind(Self::map_err(wa, Err), |fa| match fa {
-            Ok(a) => Self::pure(a),
-            Err(e) => Self::fail(Ok(e)),
-        })
-    }
-}
-
-pub type WrapE<'a, A, E, Fallible> = Wrap<'a, A, <Fallible as MonadFailAny<'a>>::W<E>>;

src/func/fail.rs

@@ -0,0 +1,86 @@
+use super::*;
+
+/// Part of [`MonadFail`] responsible for Haskell's `fail`.
+pub trait Fail<'a, E: 'a>: WeakFunctor<'a> {
+    /// Equivalent of Haskell's `fail`.
+    fn fail<A: 'a>(e: E) -> Self::F<A>;
+}
+
+/// Equivalent of Haskell's `MonadFail`. Auto-implemented for all [`Fail`]`+`[`Monad`].
+///
+/// <https://hackage.haskell.org/package/base-4.18.0.0/docs/Control-Monad.html>
+pub trait MonadFail<'a, E: 'a>: Monad<'a> + Fail<'a, E> {}
+
+impl<'a, E: 'a, T: Monad<'a> + Fail<'a, E>> MonadFail<'a, E> for T {}
+
+/// Represents a (collection of) [Monad]\(s) that can hold any type of error.
+pub trait MonadFailAny<'a>: 'a {
+    /// [`MonadFail`] for a specific error type.
+    type W<E>: MonadFail<'a, E>
+    where
+        E: 'a;
+
+    /// Associated infallible [`Monad`].
+    type T: Monad<'a>;
+
+    fn unstuff<A: 'a, E: 'a>(wa: WrapE<'a, A, E, Self>) -> Wrap<'a, Result<A, E>, Self::T>;
+
+    fn stuff<A: 'a, E: 'a>(fa: Wrap<'a, Result<A, E>, Self::T>) -> WrapE<'a, A, E, Self>;
+
+    /// Equivalent of [`Result::map_err`].
+    fn map_err<A: 'a, E0: 'a, E1: 'a>(
+        wa: WrapE<'a, A, E0, Self>,
+        f: impl 'a + FnOnce(E0) -> E1,
+    ) -> WrapE<'a, A, E1, Self> {
+        Self::bind_err(wa, |e0| Self::fail(f(e0)))
+    }
+
+    /// Equivalent of `catch`/`except`. To inject errors on success, see [`MonadFailAny::bind`].
+    fn bind_err<A: 'a, E0: 'a, E1: 'a>(
+        wa: WrapE<'a, A, E0, Self>,
+        f: impl 'a + FnOnce(E0) -> WrapE<'a, A, E1, Self>,
+    ) -> WrapE<'a, A, E1, Self> {
+        Self::bind(wa, |result| match result {
+            Ok(a) => Self::pure(a),
+            Err(e0) => f(e0),
+        })
+    }
+
+    /// Bind the result, an equivalent of `catch`/`except` with ability to "raise" extra errors
+    /// on success too, unlike [`MonadFailAny::bind_err`].
+    ///
+    /// Note: Reasonably it is expected to lack fail semantics for the underlying result.
+    /// Therefore the default implementation descends into the non-fail monad [`MonadFailAny::T`].
+    fn bind<A: 'a, B: 'a, E0: 'a, E1: 'a>(
+        wa: WrapE<'a, A, E0, Self>,
+        f: impl 'a + FnOnce(Result<A, E0>) -> WrapE<'a, B, E1, Self>,
+    ) -> WrapE<'a, B, E1, Self> {
+        Self::stuff(<Self::T as Monad>::bind(Self::unstuff(wa), |result| {
+            Self::unstuff(f(result))
+        }))
+    }
+
+    /// Equivalent of [`Monad::join`], flattening the errors.
+    ///
+    /// Note: default implementation doesn't depend on [`Monad::join`].
+    fn join<A: 'a, E0: 'a, E1: 'a>(
+        wwa: WrapE<'a, WrapE<'a, A, E0, Self>, E1, Self>,
+    ) -> WrapE<'a, A, Result<E0, E1>, Self> {
+        Self::bind(wwa, |result| match result {
+            Ok(wa) => Self::map_err(wa, Ok),
+            Err(e1) => Self::fail(Err(e1)),
+        })
+    }
+
+    /// Lift the error.
+    fn rotate_out<A: 'a, E0: 'a, E1: 'a>(
+        wa: WrapE<'a, Result<A, E1>, E0, Self>,
+    ) -> WrapE<'a, A, Result<E1, E0>, Self> {
+        <Self::W<Result<E1, E0>> as Monad>::bind(Self::map_err(wa, Err), |fa| match fa {
+            Ok(a) => Self::pure(a),
+            Err(e) => Self::fail(Ok(e)),
+        })
+    }
+}
+
+pub type WrapE<'a, A, E, Fallible> = Wrap<'a, A, <Fallible as MonadFailAny<'a>>::W<E>>;