Trait lambda_types::Function

pub trait Function<Input> {
    type Output;
}

Required Associated Types

type Output

Implementors

impl<A> Function<A> for Compose

type Output = Compose__A<A>

impl<Fn> Function<Fn> for Apply

type Output = Apply__Fn<Fn>

impl<Fn> Function<Fn> for Curry

type Output = Curry__Fn<Fn>

impl<Fn, OtherFn, Input> Function<Input> for Composed<Fn, OtherFn>

where OtherFn: Function<Input>, Fn: Function<<OtherFn as Function<Input>>::Output>,

type Output = <Fn as Function<<OtherFn as Function<Input>>::Output>>::Output

impl<Fn, X, Y> Function<Y> for Curried<Fn, X>

where Fn: Function<X>, <Fn as Function<X>>::Output: Function<Y>,

type Output = <<Fn as Function<X>>::Output as Function<Y>>::Output

impl<I, _Ignored> Function<_Ignored> for Constant<I>

type Output = I

impl<Input> Function<Input> for FirstOf

type Output = Constant<Input>

impl<Input> Function<Input> for Identity

type Output = Input

impl<Lhs> Function<Lhs> for And

type Output = And__Lhs<Lhs>

impl<Lhs> Function<Lhs> for Or

type Output = Or__Lhs<Lhs>

impl<Lhs> Function<Lhs> for Xor

type Output = Xor__Lhs<Lhs>

impl<M> Function<M> for Add

type Output = Add__M<M>

impl<M> Function<M> for Eq

type Output = Eq__M<M>

impl<M> Function<M> for Exponent

type Output = Exponent__M<M>

impl<M> Function<M> for Leq

type Output = Leq__M<M>

impl<M> Function<M> for Subtract

type Output = Subtract__M<M>

impl<N> Function<N> for IsZero

where N: Function<Constant<False>>, <N as Function<Constant<False>>>::Output: Function<True>,

type Output = <<N as Function<Constant<SecondOf>>>::Output as Function<FirstOf>>::Output

impl<N> Function<N> for Predecessor

type Output = Predecessor__N<N>

impl<N> Function<N> for Successor

type Output = Successor__N<N>

impl<N> Function<N> for ToNumber

where N: Function<ConstIncrement>, ConstIncrement: Function<ConstNumber<0>>, <N as Function<ConstIncrement>>::Output: Function<ConstNumber<0>>,

type Output = <<N as Function<ConstIncrement>>::Output as Function<ConstNumber<0>>>::Output

impl<P> Function<P> for First

where P: Function<True>,

type Output = <P as Function<FirstOf>>::Output

impl<P> Function<P> for Null

where P: Function<Constant<Constant<False>>>,

type Output = <P as Function<Constant<Constant<SecondOf>>>>::Output

impl<P> Function<P> for Second

where P: Function<False>,

type Output = <P as Function<SecondOf>>::Output

impl<Predicate> Function<Predicate> for If

type Output = If__Predicate<Predicate>

impl<Value> Function<Value> for Not

where Value: Function<False>, <Value as Function<False>>::Output: Function<True>,

type Output = <<Value as Function<SecondOf>>::Output as Function<FirstOf>>::Output

impl<X> Function<X> for Pair

type Output = Pair__X<X>

impl<X> Function<X> for Multiply

type Output = Multiply__X<X>

impl<X> Function<X> for Sheinfinkel

type Output = Sheinfinkel__X<X>

impl<_Ignored> Function<_Ignored> for SecondOf

type Output = Identity

impl<const N: u64> Function<ConstNumber<N>> for ConstIncrement

where ConstNumber<{ _ }>: Sized,

type Output = ConstNumber<{ N + 1 }>