Trait lubeck::prelude::Applicative

pub trait Applicative<'a, A>: GenType + Functor<'a, A> {
    type PureT<T>
    where
        T: 'a,
        A: 'a;

    fn pure(a: Self::PureT<A>) -> Self::Type<Self::PureT<A>>;
    fn app<F, B>(self, f: Self::Type<F>) -> Self::Type<B>
    where
        F: Fn(A) -> B + 'a,
        B: 'a;
}

Required Associated Types

type PureT<T>
where
    T: 'a,
    A: 'a

Required Methods

fn pure(a: Self::PureT<A>) -> Self::Type<Self::PureT<A>>

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

Implementations on Foreign Types

impl<'a, A> Applicative<'a, A> for Option<A>where
    A: 'a,

type PureT<T>
where
    T: 'a = T

fn pure(a: Self::PureT<A>) -> Self::Type<Self::PureT<A>>

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

impl<'a> Applicative<'a, char> for String

type PureT<T>
where
    T: 'a = char

fn pure(a: Self::PureT<()>) -> Self::Type<Self::PureT<()>>

fn app<F, B>(self, fs: Self::Type<F>) -> Self::Type<B>where
    F: Fn(char) -> B + 'a,
    B: 'a,

impl<'a, A> Applicative<'a, A> for Vec<A>where
    A: Clone + 'a,

type PureT<T>
where
    T: 'a = Vec<T, Global>

fn pure(a: Self::PureT<A>) -> Self::Type<Self::PureT<A>>

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

impl<'a, A, E> Applicative<'a, A> for Result<A, E>where
    A: 'a,

type PureT<T>
where
    T: 'a = T

fn pure(a: Self::PureT<A>) -> Self::Type<Self::PureT<A>>

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

Implementors

impl<'a, M, A> Applicative<'a, A> for OptionT<'a, M, A>where
    M: GenType<Type<Option<A>> = M> + Applicative<'a, Option<A>, PureT<Option<A>> = Option<A>> + Monad<'a, Option<A>>,
    A: 'a,

type PureT<T>
where
    T: 'a = T

impl<'a, R, A> Applicative<'a, A> for Cont<'a, R, A>where
    R: 'a,
    A: 'a,

type PureT<T>
where
    T: 'a = T

impl<'a, R, A> Applicative<'a, A> for Reader<'a, R, A>where
    R: Clone + 'a,
    A: 'a,

type PureT<T>
where
    T: 'a = T

impl<'a, R, A> Applicative<'a, A> for ReaderOptionT<'a, R, A>where
    R: Clone + 'a,
    A: 'a,

type PureT<T: 'a> = T

impl<'a, S, A> Applicative<'a, A> for State<'a, S, A>where
    S: Clone + 'a,
    A: 'a,

type PureT<T>
where
    T: 'a = T

impl<'a, W, A> Applicative<'a, A> for Writer<'a, W, A>where
    W: Monoid + 'a,
    A: 'a,

type PureT<T>
where
    T: 'a = T