Trait type_freak::functional::Functor

pub trait Functor<Input> {
    type Output;
}

Represents an applicable unit that takes input and produces output.

Associated Types

type Output

Loading content...

Implementors

impl Functor<LNil> for ApplicativeFunctor<LNil>

type Output = LNil

impl Functor<Nothing> for ApplicativeFunctor<Nothing>

type Output = Nothing

impl Functor<B0> for NotPredicate

type Output = True

impl Functor<B0> for AndPredicate<True>

type Output = False

impl Functor<B0> for AndPredicate<False>

type Output = False

impl Functor<B0> for IffPredicate<True>

type Output = False

impl Functor<B0> for IffPredicate<False>

type Output = True

impl Functor<B0> for ImplyPredicate<True>

type Output = True

impl Functor<B0> for ImplyPredicate<False>

type Output = True

impl Functor<B0> for NotImplyPredicate<True>

type Output = False

impl Functor<B0> for NotImplyPredicate<False>

type Output = False

impl Functor<B0> for OrPredicate<True>

type Output = True

impl Functor<B0> for OrPredicate<False>

type Output = False

impl Functor<B0> for XorPredicate<True>

type Output = True

impl Functor<B0> for XorPredicate<False>

type Output = False

impl Functor<B1> for NotPredicate

type Output = False

impl Functor<B1> for AndPredicate<True>

type Output = True

impl Functor<B1> for AndPredicate<False>

type Output = False

impl Functor<B1> for IffPredicate<True>

type Output = True

impl Functor<B1> for IffPredicate<False>

type Output = False

impl Functor<B1> for ImplyPredicate<True>

type Output = True

impl Functor<B1> for ImplyPredicate<False>

type Output = False

impl Functor<B1> for NotImplyPredicate<True>

type Output = False

impl Functor<B1> for NotImplyPredicate<False>

type Output = True

impl Functor<B1> for OrPredicate<True>

type Output = True

impl Functor<B1> for OrPredicate<False>

type Output = True

impl Functor<B1> for XorPredicate<True>

type Output = False

impl Functor<B1> for XorPredicate<False>

type Output = True

impl<A> Functor<(A,)> for FirstOfFunctor

type Output = A

impl<A, B> Functor<(A, B)> for FirstOfFunctor

type Output = A

impl<A, B> Functor<(A, B)> for SecondOfFunctor

type Output = B

impl<A, B, C> Functor<((A, B), C)> for RightAssociateFunctor

type Output = (A, (B, C))

impl<A, B, C> Functor<(A, (B, C))> for LeftAssociateFunctor

type Output = ((A, B), C)

impl<A, B, C> Functor<(A, B, C)> for FirstOfFunctor

type Output = A

impl<A, B, C> Functor<(A, B, C)> for SecondOfFunctor

type Output = B

impl<A, B, C> Functor<(A, B, C)> for ThirdOfFunctor

type Output = C

impl<A, B, C, D> Functor<(A, B, C, D)> for FirstOfFunctor

type Output = A

impl<A, B, C, D> Functor<(A, B, C, D)> for SecondOfFunctor

type Output = B

impl<A, B, C, D> Functor<(A, B, C, D)> for ThirdOfFunctor

type Output = C

impl<A, B, C, D, E> Functor<(A, B, C, D, E)> for FirstOfFunctor

type Output = A

impl<A, B, C, D, E> Functor<(A, B, C, D, E)> for SecondOfFunctor

type Output = B

impl<A, B, C, D, E> Functor<(A, B, C, D, E)> for ThirdOfFunctor

type Output = C

impl<DefaultValue> Functor<Nothing> for UnwrapOrFunctor<DefaultValue>

type Output = DefaultValue

impl<Func> Functor<LNil> for FMapFunctor<Func>

type Output = LNil

impl<Func> Functor<Just<Func>> for ApplicativeFunctor<Nothing>

type Output = Nothing

impl<Func> Functor<Nothing> for FMapFunctor<Func>

type Output = Nothing

impl<Func> Functor<Nothing> for MaybeFilterFunctor<Func>

type Output = Nothing

impl<Func> Functor<Nothing> for MaybeMapFunctor<Func>

type Output = Nothing

impl<Func, Head, Tail> Functor<LCons<Head, Tail>> for FMapFunctor<Func> where
    Tail: TList,
    LCons<Head, Tail>: LMapOp<Func>, 

type Output = LMapOpOutput<LCons<Head, Tail>, Func>

impl<Func, List> Functor<Func> for ApplyToTListFunctor<List> where
    List: TList + LMapOp<Func>,
    LMapOpOutput<List, Func>: TList, 

type Output = LMapOpOutput<List, Func>

impl<Func, T> Functor<Just<T>> for MaybeFilterFunctor<Func> where
    Func: Functor<T>,
    Func::Output: Maybe, 

type Output = ApplyFunctor<Func, T>

impl<Func, T> Functor<Just<T>> for MaybeMapFunctor<Func> where
    Func: Functor<T>, 

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

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

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

impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceAllFunctor where
    Tail: TList + LFoldOp<Head, AndComposePredicate>,
    LFoldOpOutput<Tail, Head, AndComposePredicate>: Boolean, 

type Output = LFoldOpOutput<Tail, Head, AndComposePredicate>

impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceAnyFunctor where
    Tail: TList + LFoldOp<Head, OrComposePredicate>,
    LFoldOpOutput<Tail, Head, OrComposePredicate>: Boolean, 

type Output = LFoldOpOutput<Tail, Head, OrComposePredicate>

impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceMaxComposeFunctor where
    Tail: TList + LFoldOp<Head, MaxComposeFunctor>, 

type Output = LFoldOpOutput<Tail, Head, MaxComposeFunctor>

impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceMinComposeFunctor where
    Tail: TList + LFoldOp<Head, MinComposeFunctor>, 

type Output = LFoldOpOutput<Tail, Head, MinComposeFunctor>

impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceProdComposeFunctor where
    Tail: TList + LFoldOp<Head, ProdComposeFunctor>, 

type Output = LFoldOpOutput<Tail, Head, ProdComposeFunctor>

impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceSumComposeFunctor where
    Tail: TList + LFoldOp<Head, SumComposeFunctor>, 

type Output = LFoldOpOutput<Tail, Head, SumComposeFunctor>

impl<Input> Functor<Input> for CountFunctor where
    Input: Counter + CountOp, 

type Output = CountOpOutput<Input>

impl<Input> Functor<Input> for IdentityFunctor

type Output = Input

impl<Input, Lhs, Rhs> Functor<Input> for Compose<Lhs, Rhs> where
    Lhs: Functor<ApplyFunctor<Rhs, Input>>,
    Rhs: Functor<Input>, 

type Output = ApplyFunctor<Lhs, ApplyFunctor<Rhs, Input>>

impl<Item, List> Functor<Item> for LPrependToFunctor<List> where
    List: TList, 

type Output = LCons<Item, List>

impl<Item, List> Functor<List> for LPrependFunctor<Item> where
    List: TList, 

type Output = LCons<Item, List>

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

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>, 

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

impl<Lhs, Rhs> Functor<(Lhs, Rhs)> for AndComposePredicate where
    Lhs: Boolean,
    Rhs: Boolean,
    AndPredicate<Rhs>: Functor<Lhs>, 

type Output = And<Lhs, Rhs>

impl<Lhs, Rhs> Functor<(Lhs, Rhs)> for IffComposePredicate where
    Lhs: Boolean,
    Rhs: Boolean,
    IffPredicate<Rhs>: Functor<Lhs>, 

type Output = Iff<Lhs, Rhs>

impl<Lhs, Rhs> Functor<(Lhs, Rhs)> for ImplyComposePredicate where
    Lhs: Boolean,
    Rhs: Boolean,
    ImplyPredicate<Rhs>: Functor<Lhs>, 

type Output = Imply<Lhs, Rhs>

impl<Lhs, Rhs> Functor<(Lhs, Rhs)> for NotImplyComposePredicate where
    Lhs: Boolean,
    Rhs: Boolean,
    NotImplyPredicate<Rhs>: Functor<Lhs>, 

type Output = NotImply<Lhs, Rhs>

impl<Lhs, Rhs> Functor<(Lhs, Rhs)> for OrComposePredicate where
    Lhs: Boolean,
    Rhs: Boolean,
    OrPredicate<Rhs>: Functor<Lhs>, 

type Output = Or<Lhs, Rhs>

impl<Lhs, Rhs> Functor<(Lhs, Rhs)> for XorComposePredicate where
    Lhs: Boolean,
    Rhs: Boolean,
    XorPredicate<Rhs>: Functor<Lhs>, 

type Output = Xor<Lhs, Rhs>

impl<Lhs, Rhs> Functor<(Lhs, Rhs)> for LConcatComposeFunctor where
    Lhs: TList + LConcatOp<Rhs>,
    Rhs: TList, 

type Output = LConcatOpOutput<Lhs, Rhs>

impl<Lhs, Rhs> Functor<(Lhs, Rhs)> for MaxComposeFunctor where
    Rhs: IsGreater<Lhs> + IfElsePredicate<Gr<Rhs, Lhs>, Lhs>,
    Gr<Rhs, Lhs>: Boolean, 

type Output = IfElsePredicateOutput<Rhs, Gr<Rhs, Lhs>, Lhs>

impl<Lhs, Rhs> Functor<(Lhs, Rhs)> for MinComposeFunctor where
    Rhs: IsLess<Lhs> + IfElsePredicate<Le<Rhs, Lhs>, Lhs>,
    Le<Rhs, Lhs>: Boolean, 

type Output = IfElsePredicateOutput<Rhs, Le<Rhs, Lhs>, Lhs>

impl<Lhs, Rhs> Functor<(Lhs, Rhs)> for ProdComposeFunctor where
    Lhs: Mul<Rhs>, 

type Output = Prod<Lhs, Rhs>

impl<Lhs, Rhs> Functor<(Lhs, Rhs)> for SumComposeFunctor where
    Lhs: Add<Rhs>, 

type Output = Sum<Lhs, Rhs>

impl<Lhs, Rhs> Functor<Lhs> for KVConcatFunctor<Rhs> where
    Lhs: KVList + LConcatOp<Rhs>,
    Rhs: KVList,
    LConcatOpOutput<Lhs, Rhs>: KVList, 

type Output = LConcatOpOutput<Lhs, Rhs>

impl<Lhs, Rhs> Functor<Lhs> for LConcatFunctor<Rhs> where
    Lhs: TList + LConcatOp<Rhs>,
    Rhs: TList, 

type Output = LConcatOpOutput<Lhs, Rhs>

impl<Lhs, Rhs> Functor<Lhs> for LZipFunctor<Rhs> where
    Lhs: TList + LZipOp<Rhs>,
    Rhs: TList, 

type Output = LZipOpOutput<Lhs, Rhs>

impl<Lhs, Rhs, Func> Functor<Lhs> for RightComposeFunctor<Rhs, Func> where
    Func: Functor<(Lhs, Rhs)>, 

type Output = ApplyFunctor<Func, (Lhs, Rhs)>

impl<Lhs, Rhs, Func> Functor<Rhs> for LeftComposeFunctor<Lhs, Func> where
    Func: Functor<(Lhs, Rhs)>, 

type Output = ApplyFunctor<Func, (Lhs, Rhs)>

impl<Lhs, Rhs, Indexes> Functor<Lhs> for KVSetEqualFuntor<Rhs, Indexes> where
    Lhs: KVList + LUnzipOp,
    Rhs: KVList + LUnzipOp,
    Indexes: TList,
    LUnzipOpFormerOutput<Lhs>: LSetEqualOp<LUnzipOpFormerOutput<Rhs>, Indexes>, 

type Output = LSetEqualOpOutput<LUnzipOpFormerOutput<Lhs>, LUnzipOpFormerOutput<Rhs>, Indexes>

impl<Lhs, Rhs, Indexes> Functor<Lhs> for LSetEqualFunctor<Rhs, Indexes> where
    Lhs: TList + LSetEqualOp<Rhs, Indexes>,
    Rhs: TList,
    Indexes: TList, 

type Output = LSetEqualOpOutput<Lhs, Rhs, Indexes>

impl<List> Functor<List> for KVLengthFunctor where
    List: KVList + LLengthOp,
    LLengthOpOutput<List>: Unsigned, 

type Output = LLengthOpOutput<List>

impl<List> Functor<List> for KVReverseFuntor where
    List: KVList,
    LReverse<List>: TList,
    LReverseFunctor: Functor<List>, 

type Output = LReverse<List>

impl<List> Functor<List> for LLengthFunctor where
    List: TList + LLengthOp, 

type Output = LLengthOpOutput<List>

impl<List> Functor<List> for LReverseFunctor where
    List: LFoldOp<LNil, LPrependComposeFunctor>,
    LFoldOpOutput<List, LNil, LPrependComposeFunctor>: TList, 

type Output = LFoldOpOutput<List, LNil, LPrependComposeFunctor>

impl<List> Functor<List> for LUnzipFunctor where
    List: TList + LUnzipOp, 

type Output = (LUnzipOpFormerOutput<List>, LUnzipOpLatterOutput<List>)

impl<List, Func> Functor<List> for LFilterFunctor<Func> where
    List: TList + LFilterOp<Func>, 

type Output = LFilterOpOutput<List, Func>

impl<List, Func> Functor<List> for LMapFunctor<Func> where
    List: TList + LMapOp<Func>, 

type Output = LMapOpOutput<List, Func>

impl<List, Init, Func> Functor<List> for LFoldFunctor<Init, Func> where
    List: TList + LFoldOp<Init, Func>, 

type Output = LFoldOpOutput<List, Init, Func>

impl<List, Init, Func> Functor<List> for LScanFunctor<Init, Func> where
    List: TList + LScanOp<Init, Func>, 

type Output = LScanOpOutput<List, Init, Func>

impl<List, Item> Functor<(List, Item)> for LPrependComposeFunctor where
    List: TList, 

type Output = LCons<Item, List>

impl<List, Item> Functor<List> for LAppendFunctor<Item> where
    List: TList + LAppendOp<Item>, 

type Output = LAppendOpOutput<List, Item>

impl<List, Item, Target, Index> Functor<List> for LInsertAtFunctor<Item, Target, Index> where
    Index: Counter,
    List: LInsertAtOp<Item, Target, Index>, 

type Output = LInsertAtOpOutput<List, Item, Target, Index>

impl<List, Key, Value> Functor<List> for KVAppendFunctor<Key, Value> where
    List: KVList,
    LAppendFunctor<(Key, Value)>: Functor<List>, 

type Output = LAppend<List, (Key, Value)>

impl<List, Key, Value> Functor<List> for KVPrependFunctor<Key, Value> where
    List: KVList,
    LAppendFunctor<(Key, Value)>: Functor<List>, 

type Output = LPrepend<List, (Key, Value)>

impl<List, Key, Value, Target, Index> Functor<List> for KVInsertAtFunctor<Key, Value, Target, Index> where
    List: KVList + KVInsertAtOp<Key, Value, Target, Index>,
    Index: Counter, 

type Output = KVInsertAtOpOutput<List, Key, Value, Target, Index>

impl<List, Target, Index> Functor<List> for KVIndexOfFunctor<Target, Index> where
    List: KVList + LUnzipOp,
    Index: Counter,
    LUnzipOpFormerOutput<List>: LIndexOfOp<Target, Index>,
    LIndexOfOpOutput<LUnzipOpFormerOutput<List>, Target, Index>: Unsigned, 

type Output = LIndexOfOpOutput<LUnzipOpFormerOutput<List>, Target, Index>

impl<List, Target, Index> Functor<List> for KVRemoveAtFunctor<Target, Index> where
    List: KVList + KVRemoveAtOp<Target, Index>,
    Index: Counter, 

type Output = KVRemoveAtOpOutput<List, Target, Index>

impl<List, Target, Index> Functor<List> for KVValueAtFunctor<Target, Index> where
    List: KVList,
    Index: Counter,
    KVKeyValueAtFunctor<Target, Index>: Functor<List>,
    SecondOfFunctor: Functor<KVKeyValueAt<List, Target, Index>>, 

type Output = SecondOf<KVKeyValueAt<List, Target, Index>>

impl<List, Target, Index> Functor<List> for LIndexOfFunctor<Target, Index> where
    List: TList + LIndexOfOp<Target, Index>,
    Index: Counter, 

type Output = LIndexOfOpOutput<List, Target, Index>

impl<List, Target, Index> Functor<List> for LRemoveAtFunctor<Target, Index> where
    List: TList + LRemoveAtOp<Target, Index>,
    Index: Counter, 

type Output = LRemoveAtOpOutput<List, Target, Index>

impl<List, Target, Index> Functor<List> for LSplitFunctor<Target, Index> where
    List: TList + LSplitOp<Target, Index>,
    Index: Counter, 

type Output = (LSplitOpFormerOutput<List, Target, Index>, LSplitOpLatterOutput<List, Target, Index>)

impl<List, Targets, Indexes> Functor<List> for KVIndexOfManyFunctor<Targets, Indexes> where
    List: KVList + LUnzipOp,
    Targets: TList,
    Indexes: TList,
    LUnzipOpFormerOutput<List>: LIndexOfManyOp<Targets, Indexes>,
    LIndexOfManyOpOutput<LUnzipOpFormerOutput<List>, Targets, Indexes>: TList, 

type Output = LIndexOfManyOpOutput<LUnzipOpFormerOutput<List>, Targets, Indexes>

impl<List, Targets, Indexes> Functor<List> for KVRemoveManyFunctor<Targets, Indexes> where
    List: KVList + KVRemoveManyOp<Targets, Indexes>,
    Targets: TList,
    Indexes: TList, 

type Output = KVRemoveManyOpOutput<List, Targets, Indexes>

impl<List, Targets, Indexes> Functor<List> for LIndexOfManyFunctor<Targets, Indexes> where
    List: TList + LIndexOfManyOp<Targets, Indexes>,
    Targets: TList,
    Indexes: TList, 

type Output = LIndexOfManyOpOutput<List, Targets, Indexes>

impl<List, Targets, Indexes> Functor<List> for LRemoveManyFunctor<Targets, Indexes> where
    List: TList + LRemoveManyOp<Targets, Indexes>,
    Targets: TList,
    Indexes: TList, 

type Output = LRemoveManyOpOutput<List, Targets, Indexes>

impl<NonTarget, Value, Tail, Target, Index> Functor<LCons<(NonTarget, Value), Tail>> for KVKeyValueAtFunctor<Target, Next<Index>> where
    Tail: KVList,
    Index: Counter,
    KVKeyValueAtFunctor<Target, Index>: Functor<Tail>, 

type Output = KVKeyValueAt<Tail, Target, Index>

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

type Output = LNil

impl<T> Functor<Just<T>> for UnwrapFunctor

type Output = T

impl<T, DefaultValue> Functor<Just<T>> for UnwrapOrFunctor<DefaultValue>

type Output = T

impl<T, Func> Functor<Just<T>> for FMapFunctor<Func> where
    MaybeMapFunctor<Func>: Functor<Just<T>>, 

type Output = MaybeMap<Just<T>, Func>

impl<Target, Value, Tail> Functor<LCons<(Target, Value), Tail>> for KVKeyValueAtFunctor<Target, Current> where
    Tail: KVList, 

type Output = (Target, Value)

impl<Value> Functor<Nothing> for ApplicativeFunctor<Just<Value>>

type Output = Nothing

impl<Value> Functor<Value> for AddOneFunctor where
    Value: Add<B1>, 

type Output = Add1<Value>

impl<Value> Functor<Value> for SubOneFunctor where
    Value: Sub<B1>, 

type Output = Sub1<Value>

Loading content...