Trait radn::func::Monad

pub trait Monad<'a>: Applicative<'a> {
    // Required methods
    fn bind<A: 'a + Send, B: 'a + Send>(
        fa: Self::F<A>,
        f: impl 'a + Send + FnOnce(A) -> Self::F<B>
    ) -> Self::F<B>;
    fn iterate<B: 'a + Send>(
        f: impl Iterative<'a, T = Self, B = B>
    ) -> Self::F<B>;

    // Provided method
    fn join<A: 'a + Send>(ffa: Self::F<Self::F<A>>) -> Self::F<A> { ... }
}

Equivalent of Haskell’s Monad.

https://hackage.haskell.org/package/base-4.18.0.0/docs/Control-Monad.html

Required Methods

fn bind<A: 'a + Send, B: 'a + Send>( fa: Self::F<A>, f: impl 'a + Send + FnOnce(A) -> Self::F<B> ) -> Self::F<B>

Equivalent of Haskell’s >==. Due to Rust limitations, it’s not a function->function conversion. For that see derivations::bind.

fn iterate<B: 'a + Send>(f: impl Iterative<'a, T = Self, B = B>) -> Self::F<B>

Included for optimisation and clarity. Generally, Monad::bind should be enough implement it. See StacklessInstance::iterate for a generic, though less-than ideal, blanket implementation. On practice, you generally shouldn’t be using Monad::bind/Pure::pure/Functor::fmap here.

Provided Methods

fn join<A: 'a + Send>(ffa: Self::F<Self::F<A>>) -> Self::F<A>

Equivalent of Haskell’s join.

Implementors

impl<'a> Monad<'a> for FutureInstance

impl<'a> Monad<'a> for LazyInstance

impl<'a> Monad<'a> for OptionInstance

impl<'a> Monad<'a> for SoloInstance

impl<'a> Monad<'a> for StacklessInstance

impl<'a, E: 'a + Send> Monad<'a> for ResultInstance<E>

impl<'a, E: 'a + Send> Monad<'a> for TryFutureInstance<E>

impl<'a, E: 'a + Effect> Monad<'a> for EffectInstance<E>

impl<'a, T: Monad<'a>, O: 'a + DeriveMonad> Monad<'a> for OverloadInstance<T, O>

impl<'a, U: Monad<'a>, V: Monad<'a> + LocalFunctor<'a>> Monad<'a> for CompositionInstance<U, V>