Trait App 

pub trait App<Ia: Value>: Value<Type = Lambda<<Ia as Value>::Type, <Self::Result as Value>::Type>> {
    type Result: Value;
}

Required Associated Types

type Result: Value

Implementors

impl App<False> for EqTo<False>

type Result = True

impl App<False> for EqTo<True>

type Result = False

impl App<False> for Neg

type Result = True

impl App<False> for OrOn<False>

type Result = False

impl App<False> for OrOn<True>

type Result = True

impl App<True> for EqTo<False>

type Result = False

impl App<True> for EqTo<True>

type Result = True

impl App<True> for Neg

type Result = False

impl App<Z> for EqTo<Z>

type Result = True

impl<A, B, Ia: Value<Type = A>, Ib: Value<Type = B>> App<(Ia, Ib)> for Snd<A, B>

where A: TypeOf<Ia> + Type, B: TypeOf<Ib> + Type,

type Result = Ib

impl<A: Type, B: Type, C: Type, F, G, Ia: Value<Type = A>, Ib: Value<Type = B>, Ic: Value<Type = C>> App<Ia> for Compose<F, G>

where F: App<Ia, Result = Ib> + Value<Type = Lambda<A, B>>, G: App<Ib, Result = Ic> + Value<Type = Lambda<B, C>>,

type Result = Ic

impl<A: Type, B: Type, F: Value<Type = Lambda<A, List<B>>> + App<Current, Result = CurrentResult>, Current: Value<Type = A>, Next: Value<Type = List<A>>, CurrentResult: Value<Type = List<B>>, NextResult: Value<Type = List<B>>, Result: Value<Type = List<B>>> App<Segment<Current, Next>> for BindOn<List<A>, F>

where BindOn<List<A>, F>: Value + App<Next, Result = NextResult>, ConcatWith<NextResult>: Value + App<CurrentResult, Result = Result>,

type Result = Result

impl<A: Type, B: Type, F: Value<Type = Lambda<A, List<B>>>> App<Empty<A>> for BindOn<List<A>, F>

type Result = Empty<B>

impl<A: Type, B: Type, F: Value<Type = Lambda<A, Maybe<B>>> + App<Ia, Result = R>, Ia: Value<Type = A>, R: Value<Type = Maybe<B>>> App<Just<Ia>> for BindOn<Maybe<A>, F>

type Result = R

impl<A: Type, B: Type, F: Value<Type = Lambda<A, Maybe<B>>>> App<Nothing<A>> for BindOn<Maybe<A>, F>

type Result = Nothing<B>

impl<A: Type, B: Type, F: Value<Type = Lambda<A, B>> + App<Ia, Result = Ib>, Ia: Value<Type = A>, Ib: Value<Type = B>, La: Value<Type = List<A>>, Lb: Value<Type = List<B>>> App<Segment<Ia, La>> for MapOn<List<A>, F>

where MapOn<List<A>, F>: Value<Type = Lambda<List<A>, List<B>>> + App<La, Result = Lb>,

type Result = Segment<Ib, Lb>

impl<A: Type, B: Type, F: Value<Type = Lambda<A, B>> + App<V, Result = R>, V: Value<Type = A>, R: Value<Type = B>> App<Just<V>> for MapOn<Maybe<A>, F>

type Result = Just<R>

impl<A: Type, B: Type, F: Value<Type = Lambda<A, B>>> App<Empty<A>> for MapOn<List<A>, F>

type Result = Empty<B>

impl<A: Type, B: Type, F: Value<Type = Lambda<A, B>>> App<Nothing<A>> for MapOn<Maybe<A>, F>

type Result = Nothing<B>

impl<A: Type, B: Type, Ia: Value<Type = A>, Ib: Value<Type = B>> App<(Ia, Ib)> for Fst<A, B>

type Result = Ia

impl<A: Value<Type = Nat>> App<Z> for AddOn<A>

type Result = A

impl<A: Value<Type = Nat>, B: Value<Type = Nat>, R: Value<Type = Nat>> App<S<B>> for AddOn<A>

where AddOn<A>: Value<Type = Lambda<Nat, Nat>> + App<B, Result = R>,

type Result = S<R>

impl<L: Value<Type = Nat>, R: Value<Type = Nat>, Eq: Value<Type = Bool>> App<S<R>> for EqTo<S<L>>

where EqTo<L>: App<R, Result = Eq>,

type Result = Eq

impl<T: Type> App<Nothing<Maybe<T>>> for Flatten<T>

type Result = Nothing<T>

impl<T: Type> App<Nothing<T>> for IsNoting<T>

type Result = True

impl<T: Type> App<Nothing<T>> for ToList<T>

type Result = Empty<T>

impl<T: Type, A: Type, B: Type, Fa: Value<Type = Lambda<A, T>> + App<Pa, Result = R>, Pa: Value<Type = A>, Fb: Value<Type = Lambda<B, T>>, Pb: Value<Type = B>, R: Value<Type = T>> App<True> for LambdaBranch<Fa, Pa, Fb, Pb>

type Result = R

impl<T: Type, A: Type, B: Type, Fa: Value<Type = Lambda<A, T>>, Pa: Value<Type = A>, Fb: Value<Type = Lambda<B, T>> + App<Pb, Result = R>, Pb: Value<Type = B>, R: Value<Type = T>> App<False> for LambdaBranch<Fa, Pa, Fb, Pb>

type Result = R

impl<T: Type, F: Value<Type = Lambda<T, Bool>> + App<Current, Result = CurrentResult>, Current: Value<Type = T>, Next: Value<Type = List<T>>, NextResult: Value<Type = List<T>>, CurrentResult: Value<Type = Bool>, CurrentMaybe: Value<Type = Maybe<T>>, Listed: Value<Type = List<T>>, Result: Value<Type = List<T>>> App<Segment<Current, Next>> for FilterOn<F>

where FilterOn<F>: App<Next, Result = NextResult>, WhenMaybe<Just<Current>>: App<CurrentResult, Result = CurrentMaybe>, ToList<T>: App<CurrentMaybe, Result = Listed>, ConcatWith<Next>: App<Listed, Result = Result>,

type Result = Result

impl<T: Type, F: Value<Type = Lambda<T, Bool>>> App<Empty<T>> for FilterOn<F>

type Result = Empty<T>

impl<T: Type, I: Value<Type = Maybe<T>>> App<Just<I>> for Flatten<T>

type Result = I

impl<T: Type, I: Value<Type = T>> App<Empty<T>> for ContainIn<I>

type Result = False

impl<T: Type, I: Value<Type = T>> App<I> for Id<T>

type Result = I

impl<T: Type, I: Value<Type = T>, L: Value<Type = List<T>>> App<L> for PushTo<I>

type Result = Segment<I, L>

impl<T: Type, I: Value<Type = T>, LI: Value<Type = T>, L: Value<Type = List<T>>, Eq: Value<Type = Bool>, C: Value<Type = Bool>, R: Value<Type = Bool>> App<Segment<LI, L>> for ContainIn<I>

where EqTo<I>: App<LI, Result = Eq>, ContainIn<I>: App<L, Result = C>, OrOn<Eq>: App<C, Result = R>,

type Result = R

impl<T: Type, L: Value<Type = List<T>>> App<Empty<T>> for ConcatWith<L>

type Result = L

impl<T: Type, L: Value<Type = List<T>>, I: Value<Type = T>> App<Segment<I, Empty<T>>> for ConcatWith<L>

type Result = Segment<I, L>

impl<T: Type, L: Value<Type = List<T>>, I: Value<Type = T>, NextI: Value<Type = T>, Next: Value<Type = List<T>>, NextResult: Value<Type = List<T>>> App<Segment<I, Segment<NextI, Next>>> for ConcatWith<L>

where ConcatWith<L>: App<Segment<NextI, Next>, Result = NextResult>,

type Result = Segment<I, NextResult>

impl<T: Type, V: Value<Type = T>> App<False> for WhenMaybe<V>

type Result = Nothing<T>

impl<T: Type, V: Value<Type = T>> App<False> for WhenMaybeF<V>

type Result = Just<V>

impl<T: Type, V: Value<Type = T>> App<Just<V>> for IsNoting<T>

type Result = False

impl<T: Type, V: Value<Type = T>> App<Just<V>> for ToList<T>

type Result = <Pure<List<T>> as App<V>>::Result

impl<T: Type, V: Value<Type = T>> App<True> for WhenMaybe<V>

type Result = Just<V>

impl<T: Type, V: Value<Type = T>> App<True> for WhenMaybeF<V>

type Result = Nothing<T>

impl<T: Type, V: Value<Type = T>> App<V> for Pure<List<T>>

type Result = Segment<V, Empty<T>>

impl<T: Type, V: Value<Type = T>> App<V> for Pure<Maybe<T>>

type Result = Just<V>

impl<T: Value<Type = Bool>> App<True> for OrOn<T>

type Result = True

impl<T: Value<Type = Nat>> App<S<T>> for EqTo<Z>

type Result = False

impl<T: Value<Type = Nat>> App<Z> for EqTo<S<T>>

type Result = False