72 lines
2.1 KiB
Rust
72 lines
2.1 KiB
Rust
use super::{fail::*, *};
|
|
|
|
pub type WrapC<'a, A, Ctx> = Wrap<'a, A, <Ctx as FunctorContext<'a>>::T>;
|
|
|
|
pub trait FunctorContext<'a>: 'a {
|
|
type T: WeakFunctor<'a>;
|
|
}
|
|
|
|
pub trait FunctorContextExt<'a>: FunctorContext<'a> {
|
|
fn fmap<A: 'a, B: 'a>(fa: WrapC<'a, A, Self>, f: impl 'a + FnOnce(A) -> B) -> WrapC<'a, B, Self>
|
|
where
|
|
Self::T: Functor<'a>,
|
|
{
|
|
<Self::T as Functor>::fmap(fa, f)
|
|
}
|
|
|
|
fn pure<A: 'a>(a: A) -> WrapC<'a, A, Self>
|
|
where
|
|
Self::T: Pure<'a>,
|
|
{
|
|
<Self::T as Pure>::pure(a)
|
|
}
|
|
|
|
fn bind<A: 'a, B: 'a>(
|
|
fa: WrapC<'a, A, Self>,
|
|
f: impl 'a + FnOnce(A) -> WrapC<'a, B, Self>,
|
|
) -> WrapC<'a, B, Self>
|
|
where
|
|
Self::T: Monad<'a>,
|
|
{
|
|
<Self::T as Monad>::bind(fa, f)
|
|
}
|
|
|
|
fn fail<A: 'a, E: 'a>(e: E) -> WrapC<'a, A, Self>
|
|
where
|
|
Self::T: Fail<'a, E>,
|
|
{
|
|
<Self::T as Fail<_>>::fail(e)
|
|
}
|
|
}
|
|
|
|
impl<'a, Ctx: FunctorContext<'a>> FunctorContextExt<'a> for Ctx {}
|
|
|
|
pub trait FallibleCtx<'a>: FunctorContext<'a> {
|
|
/// Type to allow improved support for [`Result`] evaluation.
|
|
/// This is important for async applications stopping early.
|
|
type Fallible: MonadFailAny<'a, T = Self::T>;
|
|
}
|
|
|
|
/// Preferred monad for fallible uses.
|
|
pub type FallibleMonad<'a, Ctx, E> = <<Ctx as FallibleCtx<'a>>::Fallible as MonadFailAny<'a>>::W<E>;
|
|
|
|
/// Preferred [Wrap]ped [Result].
|
|
pub type FallibleWrapped<'a, Ctx, A, E> = Wrap<'a, A, FallibleMonad<'a, Ctx, E>>;
|
|
|
|
/// Extention trait for simpler conversion between [`FunctorContext::T`] and [`FallibleCtx::Fallible`].
|
|
///
|
|
/// this is the preferred way to switch between [WrapC] and [FallibleWrapped].
|
|
pub trait FallibleCtxExt<'a>: FallibleCtx<'a> {
|
|
/// Convert a fallible wrapped into a wrapped result.
|
|
fn unstuff<A: 'a, E: 'a>(wa: FallibleWrapped<'a, Self, A, E>) -> WrapC<'a, Result<A, E>, Self> {
|
|
Self::Fallible::unstuff(wa)
|
|
}
|
|
|
|
/// Convert a wrapped result into a fallible wrapped.
|
|
fn stuff<A: 'a, E: 'a>(fa: WrapC<'a, Result<A, E>, Self>) -> FallibleWrapped<'a, Self, A, E> {
|
|
Self::Fallible::stuff(fa)
|
|
}
|
|
}
|
|
|
|
impl<'a, Ctx: FallibleCtx<'a>> FallibleCtxExt<'a> for Ctx {}
|