Trait higher::Bind

pub trait Bind<'a, A> {
    type Target<T>;

    fn bind<B, F>(self, f: F) -> Self::Target<B>
    where
        F: Fn(A) -> Self::Target<B> + 'a;
}

Bind lets you chain computations together.

It takes a function Fn(A) -> M<B> and applies it to the A inside M<A>. You can think of this as a callback function for when the value of A is ready to be processed, returning the next computation in the sequence.

This is the primary component of the dreaded Monad trait, but to be a Monad a type must also implement Applicative, which in turn requires implementations for Functor, Pure and Apply.

Required Associated Types

type Target<T>

Required Methods

fn bind<B, F>(self, f: F) -> Self::Target<B>where
    F: Fn(A) -> Self::Target<B> + 'a,

Implementations on Foreign Types

impl<A> Bind<'_, A> for Option<A>

type Target<T> = Option<T>

fn bind<B, F>(self, f: F) -> Self::Target<B>where
    F: Fn(A) -> Self::Target<B>,

impl<A, E> Bind<'_, A> for Result<A, E>

type Target<T> = Result<T, E>

fn bind<B, F>(self, f: F) -> Self::Target<B>where
    F: Fn(A) -> Self::Target<B>,

impl<A> Bind<'_, A> for Vec<A>

type Target<T> = Vec<T, Global>

fn bind<B, F>(self, f: F) -> Self::Target<B>where
    F: Fn(A) -> Self::Target<B>,

Implementors

impl<'a, A> Bind<'a, A> for Effect<'a, A>where
    A: 'a,

type Target<T> = Effect<'a, T>

impl<'a, A: 'a, E: 'a> Bind<'a, A> for IO<'a, A, E>

type Target<T> = IO<'a, T, E>