[−][src]Struct type_freak::functional::ApplicativeFunctor

pub struct ApplicativeFunctor<Rhs> { /* fields omitted */ }

A Functor that applies input wrapped Functor to Rhs contained type.

Trait Implementations

impl Functor<LNil> for ApplicativeFunctor<LNil>[src]

type Output = LNil

impl<LHead, LTail> Functor<LCons<LHead, LTail>> for ApplicativeFunctor<LNil> where
    LTail: TList, [src]

type Output = LNil

impl<RHead, RTail> Functor<LNil> for ApplicativeFunctor<LCons<RHead, RTail>> where
    RTail: TList, [src]

type Output = LNil

impl<LHead, LTail, RHead, RTail> Functor<LCons<LHead, LTail>> for ApplicativeFunctor<LCons<RHead, RTail>> where
    LTail: TList,
    RTail: TList,
    LCons<LHead, LTail>: LMapOp<ApplyToTListFunctor<LCons<RHead, RTail>>>,
    LMapOpOutput<LCons<LHead, LTail>, ApplyToTListFunctor<LCons<RHead, RTail>>>: LFoldOp<LNil, LConcatComposeFunctor>, [src]

type Output = LFoldOpOutput<LMapOpOutput<LCons<LHead, LTail>, ApplyToTListFunctor<LCons<RHead, RTail>>>, LNil, LConcatComposeFunctor>

impl Functor<Nothing> for ApplicativeFunctor<Nothing>[src]

type Output = Nothing

impl<Func> Functor<Just<Func>> for ApplicativeFunctor<Nothing>[src]

type Output = Nothing

impl<Value> Functor<Nothing> for ApplicativeFunctor<Just<Value>>[src]

type Output = Nothing

impl<Func, Value> Functor<Just<Func>> for ApplicativeFunctor<Just<Value>> where
    Func: Functor<Value>, [src]

type Output = Just<ApplyFunctor<Func, Value>>

Auto Trait Implementations

impl<Rhs> Sync for ApplicativeFunctor<Rhs> where
    Rhs: Sync, 

impl<Rhs> Send for ApplicativeFunctor<Rhs> where
    Rhs: Send, 

impl<Rhs> Unpin for ApplicativeFunctor<Rhs> where
    Rhs: Unpin, 

impl<Rhs> UnwindSafe for ApplicativeFunctor<Rhs> where
    Rhs: UnwindSafe, 

impl<Rhs> RefUnwindSafe for ApplicativeFunctor<Rhs> where
    Rhs: RefUnwindSafe, 

Blanket Implementations

impl<Cond, Output> If<Cond> for Output[src]

type Output = <FirstOfFunctor as Functor<(Output, Cond)>>::Output

impl<Same, Output> IfSame<Same, Same> for Output[src]

type Output = Output

impl<Output> IfPredicate<B1> for Output[src]

type Output = Output

impl<Output> IfNotPredicate<B0> for Output[src]

type Output = Output

impl<TrueOutput, FalseOutput> IfElsePredicate<B1, FalseOutput> for TrueOutput[src]

type Output = TrueOutput

impl<TrueOutput, FalseOutput> IfElsePredicate<B0, FalseOutput> for TrueOutput[src]

type Output = FalseOutput

impl<Lhs, Rhs, Output> IfLess<Lhs, Rhs> for Output where
    Lhs: IsLess<Rhs>,
    Output: IfPredicate<<Lhs as IsLess<Rhs>>::Output>,
    <Lhs as IsLess<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfPredicate<<Lhs as IsLess<Rhs>>::Output>>::Output

impl<Lhs, Rhs, Output, Else> IfElseLess<Lhs, Rhs, Else> for Output where
    Lhs: IsLess<Rhs>,
    Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
    <Lhs as IsLess<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>>::Output

impl<Lhs, Rhs, Output> IfLessOrEqual<Lhs, Rhs> for Output where
    Lhs: IsLessOrEqual<Rhs>,
    Output: IfPredicate<<Lhs as IsLessOrEqual<Rhs>>::Output>,
    <Lhs as IsLessOrEqual<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfPredicate<<Lhs as IsLessOrEqual<Rhs>>::Output>>::Output

impl<Lhs, Rhs, Output, Else> IfElseLessOrEqual<Lhs, Rhs, Else> for Output where
    Lhs: IsLess<Rhs>,
    Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
    <Lhs as IsLess<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>>::Output

impl<Lhs, Rhs, Output> IfGreater<Lhs, Rhs> for Output where
    Lhs: IsGreater<Rhs>,
    Output: IfPredicate<<Lhs as IsGreater<Rhs>>::Output>,
    <Lhs as IsGreater<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfPredicate<<Lhs as IsGreater<Rhs>>::Output>>::Output

impl<Lhs, Rhs, Output, Else> IfElseGreater<Lhs, Rhs, Else> for Output where
    Lhs: IsLess<Rhs>,
    Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
    <Lhs as IsLess<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>>::Output

impl<Lhs, Rhs, Output> IfGreaterOrEqual<Lhs, Rhs> for Output where
    Lhs: IsGreaterOrEqual<Rhs>,
    Output: IfPredicate<<Lhs as IsGreaterOrEqual<Rhs>>::Output>,
    <Lhs as IsGreaterOrEqual<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfPredicate<<Lhs as IsGreaterOrEqual<Rhs>>::Output>>::Output

impl<Lhs, Rhs, Output, Else> IfElseGreaterOrEqual<Lhs, Rhs, Else> for Output where
    Lhs: IsLess<Rhs>,
    Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
    <Lhs as IsLess<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>>::Output

impl<Lhs, Rhs, Output> IfEqual<Lhs, Rhs> for Output where
    Lhs: IsEqual<Rhs>,
    Output: IfPredicate<<Lhs as IsEqual<Rhs>>::Output>,
    <Lhs as IsEqual<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfPredicate<<Lhs as IsEqual<Rhs>>::Output>>::Output

impl<Lhs, Rhs, Output, Else> IfElseEqual<Lhs, Rhs, Else> for Output where
    Lhs: IsEqual<Rhs>,
    Output: IfElsePredicate<<Lhs as IsEqual<Rhs>>::Output, Else>,
    <Lhs as IsEqual<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfElsePredicate<<Lhs as IsEqual<Rhs>>::Output, Else>>::Output

impl<Output> IfZero<B0> for Output[src]

type Output = Output

impl<Output> IfZero<Z0> for Output[src]

type Output = Output

impl<Output> IfZero<UTerm> for Output[src]

type Output = Output

impl<Value, Output> IfNonZero<Value> for Output where
    Value: NonZero, [src]

type Output = Output

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> From<T> for T[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Same<T> for T[src]

type Output = T

Should always be Self