Trait type_level_values::type_fn::TypeFn_

pub trait TypeFn_<Params> {
    type Output;
}

A type-level function.

Type-level functions is what this library calls every implementor of this trait.

Implementations

The preferred way to implement this trait is using the type_fn macro.

Example

Implementing a multiply add operation.

use type_level_values::fn_types::{MulOp,AddOp};
use type_level_values::prelude::*;


use std::ops::{Mul,Add};

type_fn!{
    pub fn MulAdd[L,R](L,R)
    where[
        L:Mul<R,Output=res0>,
        res0:Add<R,Output=res1>,
    ]{
        let res0;
        let res1;
        res1
    }
}

fn main(){
    let _:U20=TypeFn::<MulAdd,(U4,U4)>::MTVAL;
    let _:U50=TypeFn::<MulAdd,(U4,U10)>::MTVAL;
}

A more advanced version,using function composition

use type_level_values::fn_adaptors::ApplyRhs;
use type_level_values::fn_types::{MulOp,AddOp};
use type_level_values::prelude::*;


type_fn!{
    pub fn MulAdd[L,R](L,R)
    where[ tlist![ MulOp, ApplyRhs<AddOp,R> ]:TypeFn_<(L,R),Output=out> ]
    { let out;out }
}

fn main(){
    let _:U20=TypeFn::<MulAdd,(U4,U4)>::MTVAL;
    let _:U50=TypeFn::<MulAdd,(U4,U10)>::MTVAL;
}

Example

Emulating type constructors with a TypeFn_.

use type_level_values::prelude::*;


use std::collections::{BTreeSet,BTreeMap};

type_fn!{pub fn VecFn[T](T){ Vec<T> }}

type_fn!{pub fn BTreeSetFn[T](T){ BTreeSet<T> }}

type_fn!{pub fn BTreeMapFn[K,V](K,V){ BTreeMap<K,V> }}

fn main(){
    let _:TypeFn<VecFn,usize> =
        Vec::<usize>::new();

    let _:TypeFn<BTreeSetFn,usize> =
        BTreeSet::<usize>::new();

    let _:TypeFn<BTreeMapFn,(String,usize)> =
        BTreeMap::<String,usize>::new();
}

Example

Implementing a function which unwraps a type-level Option<_> or else returns the value from the default function.

The default capture gets translated to the type parameter of UnwrapOrElse.

use type_level_values::fn_adaptors::{Const};
use type_level_values::prelude::*;



type_fn!{
    captures(default)

    pub fn
        UnwrapOrElse[T](Some_<T>)
        { T }
        
        UnwrapOrElse(None_)
        where[ default:TypeFn_<()> ]
        { default::Output }

}

fn main(){
    let _:U10=TypeFn::<UnwrapOrElse<Const<U0>>, Some_<U10>>::MTVAL;
    let _:U5 =TypeFn::<UnwrapOrElse<Const<U5>>, None_     >::MTVAL;
}

Associated Types

type Output

The return value of the function

Implementations on Foreign Types

impl<R> TypeFn_<R> for ()

type Output = R

impl<T0, Param> TypeFn_<Param> for (T0,) where     T0: TypeFn_<Param>,

type Output = T0::Output

impl<T0, T1, Param> TypeFn_<Param> for (T0, T1) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,

type Output = T1::Output

impl<T0, T1, T2, Param> TypeFn_<Param> for (T0, T1, T2) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,

type Output = T2::Output

impl<T0, T1, T2, T3, Param> TypeFn_<Param> for (T0, T1, T2, T3) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,

type Output = T3::Output

impl<T0, T1, T2, T3, T4, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,

type Output = T4::Output

impl<T0, T1, T2, T3, T4, T5, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4, T5) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,     T5: TypeFn_<T4::Output>,

type Output = T5::Output

impl<T0, T1, T2, T3, T4, T5, T6, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4, T5, T6) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,     T5: TypeFn_<T4::Output>,     T6: TypeFn_<T5::Output>,

type Output = T6::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4, T5, T6, T7) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,     T5: TypeFn_<T4::Output>,     T6: TypeFn_<T5::Output>,     T7: TypeFn_<T6::Output>,

type Output = T7::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,     T5: TypeFn_<T4::Output>,     T6: TypeFn_<T5::Output>,     T7: TypeFn_<T6::Output>,     T8: TypeFn_<T7::Output>,

type Output = T8::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,     T5: TypeFn_<T4::Output>,     T6: TypeFn_<T5::Output>,     T7: TypeFn_<T6::Output>,     T8: TypeFn_<T7::Output>,     T9: TypeFn_<T8::Output>,

type Output = T9::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,     T5: TypeFn_<T4::Output>,     T6: TypeFn_<T5::Output>,     T7: TypeFn_<T6::Output>,     T8: TypeFn_<T7::Output>,     T9: TypeFn_<T8::Output>,     T10: TypeFn_<T9::Output>,

type Output = T10::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,     T5: TypeFn_<T4::Output>,     T6: TypeFn_<T5::Output>,     T7: TypeFn_<T6::Output>,     T8: TypeFn_<T7::Output>,     T9: TypeFn_<T8::Output>,     T10: TypeFn_<T9::Output>,     T11: TypeFn_<T10::Output>,

type Output = T11::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,     T5: TypeFn_<T4::Output>,     T6: TypeFn_<T5::Output>,     T7: TypeFn_<T6::Output>,     T8: TypeFn_<T7::Output>,     T9: TypeFn_<T8::Output>,     T10: TypeFn_<T9::Output>,     T11: TypeFn_<T10::Output>,     T12: TypeFn_<T11::Output>,

type Output = T12::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,     T5: TypeFn_<T4::Output>,     T6: TypeFn_<T5::Output>,     T7: TypeFn_<T6::Output>,     T8: TypeFn_<T7::Output>,     T9: TypeFn_<T8::Output>,     T10: TypeFn_<T9::Output>,     T11: TypeFn_<T10::Output>,     T12: TypeFn_<T11::Output>,     T13: TypeFn_<T12::Output>,

type Output = T13::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,     T5: TypeFn_<T4::Output>,     T6: TypeFn_<T5::Output>,     T7: TypeFn_<T6::Output>,     T8: TypeFn_<T7::Output>,     T9: TypeFn_<T8::Output>,     T10: TypeFn_<T9::Output>,     T11: TypeFn_<T10::Output>,     T12: TypeFn_<T11::Output>,     T13: TypeFn_<T12::Output>,     T14: TypeFn_<T13::Output>,

type Output = T14::Output

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, Param> TypeFn_<Param> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where     T0: TypeFn_<Param>,     T1: TypeFn_<T0::Output>,     T2: TypeFn_<T1::Output>,     T3: TypeFn_<T2::Output>,     T4: TypeFn_<T3::Output>,     T5: TypeFn_<T4::Output>,     T6: TypeFn_<T5::Output>,     T7: TypeFn_<T6::Output>,     T8: TypeFn_<T7::Output>,     T9: TypeFn_<T8::Output>,     T10: TypeFn_<T9::Output>,     T11: TypeFn_<T10::Output>,     T12: TypeFn_<T11::Output>,     T13: TypeFn_<T12::Output>,     T14: TypeFn_<T13::Output>,     T15: TypeFn_<T14::Output>,

type Output = T15::Output

Implementors

• impl<A, B> TypeFn_<(A, B)> for AddOp where     A: Std_Add<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for BitAndOp where     A: Std_BitAnd<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for BitXorOp where     A: Std_BitXor<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for BitOrOp where     A: Std_BitOr<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for DivOp where     A: Std_Div<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for IndexOp where     A: Std_Index<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for IndexMutOp where     A: Std_IndexMut<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for MulOp where     A: Std_Mul<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A> TypeFn_<A> for NegOp where     A: Std_Neg,     A::Output: Sized,  type Output = A::Output;

• impl<A> TypeFn_<A> for NotOp where     A: Std_Not,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for RemOp where     A: Std_Rem<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for ShlOp where     A: Std_Shl<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for ShrOp where     A: Std_Shr<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for SubOp where     A: Std_Sub<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for ConstOrdOp where     A: ConstOrd_<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for ConstEqOp where     A: ConstEq_<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for ConstNEOp where     A: ConstNE_<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for ConstFromOp where     A: ConstFrom_<B>,     A::Output: Sized,  type Output = A::Output;

• impl<A, B> TypeFn_<(A, B)> for ConstIntoOp where     A: ConstInto_<B>,     A::Output: Sized,  type Output = A::Output;

• impl<L, R, Out> TypeFn_<(L, R)> for ConstLtOp where     L: ConstOrd_<R>,     L::Output: ConstEq_<Less_, Output = Out>,     Out: Boolean,  type Output = Out;

• impl<L, R, Out> TypeFn_<(L, R)> for ConstLEOp where     L: ConstOrd_<R>,     IsLessOrEqual: TypeFn_<L::Output, Output = Out>,  type Output = Out;

• impl<L, R, Out> TypeFn_<(L, R)> for ConstGtOp where     L: ConstOrd_<R>,     L::Output: ConstEq_<Greater_, Output = Out>,     Out: Boolean,  type Output = Out;

• impl<L, R, Out> TypeFn_<(L, R)> for ConstGEOp where     L: ConstOrd_<R>,     IsGreaterOrEqual: TypeFn_<L::Output, Output = Out>,  type Output = Out;

• impl<Lhs, Op, Rhs> TypeFn_<Lhs> for ApplyRhs<Op, Rhs> where     Op: TypeFn_<(Lhs, Rhs)>,  type Output = Op::Output;

• impl<Rhs, Op, Lhs> TypeFn_<Rhs> for ApplyLhs<Op, Lhs> where     Op: TypeFn_<(Lhs, Rhs)>,  type Output = Op::Output;

• impl<Input, Op, Nth, Value> TypeFn_<Input> for ApplyNth<Op, Nth, Value> where     Input: Insert_<Nth, Value>,     Op: TypeFn_<Input::Output>,  type Output = Op::Output;

• impl<Input, Op, Nth, Value> TypeFn_<Input> for ApplyNonNth<Op, Nth, Value> where     Value: Insert_<Nth, Input>,     Op: TypeFn_<Value::Output>,  type Output = Op::Output;

• impl<Lhs, Rhs, Op, Mapper, Res0> TypeFn_<(Lhs, Rhs)> for MapLhs<Op, Mapper> where     Mapper: TypeFn_<Lhs, Output = Res0>,     Op: TypeFn_<(Res0, Rhs)>,  type Output = Op::Output;

• impl<Lhs, Rhs, Op, Mapper, Res0> TypeFn_<(Lhs, Rhs)> for MapRhs<Op, Mapper> where     Mapper: TypeFn_<Rhs, Output = Res0>,     Op: TypeFn_<(Lhs, Res0)>,  type Output = Op::Output;

• impl<Params, Op, Nth, Mapper, Res0> TypeFn_<Params> for MapNth<Op, Nth, Mapper> where     MapFieldOp: TypeFn_<(Params, Nth, Mapper), Output = Res0>,     Op: TypeFn_<Res0>,  type Output = Op::Output;

• impl<Lhs, Rhs> TypeFn_<(Lhs, Rhs)> for EvalRhsOp where     Rhs: TypeFn_<Lhs>,  type Output = Rhs::Output;

• impl<Lhs, Rhs> TypeFn_<(Lhs, Rhs)> for EvalLhsOp where     Lhs: TypeFn_<Rhs>,  type Output = Lhs::Output;

• impl<L, R> TypeFn_<(L, R)> for ReturnLhs type Output = L;

• impl<L, R> TypeFn_<(L, R)> for ReturnRhs type Output = R;

• impl<Params, Value> TypeFn_<Params> for Const<Value> type Output = Value;

• impl<Params, T> TypeFn_<Params> for Ignoring<T> type Output = Params;

• impl<P> TypeFn_<P> for IdentityFn type Output = P;

• impl<Input, F> TypeFn_<Input> for TupledIn<F> where     F: TypeFn_<(Input,)>,  type Output = F::Output;

• impl<This> TypeFn_<This> for AsTListOp where     This: AsTList_,  type Output = This::Output;

• impl<This> TypeFn_<This> for VariantAsTListOp where     This: VariantAsTList_,  type Output = This::Output;

• impl<Function, Params> TypeFn_<()> for Lazy<Function, Params> where     Function: TypeFn_<Params>,  type Output = Function::Output;

• impl<state, Pred, Then, Else, out> TypeFn_<state> for If<Pred, Then, Else> where     Pred: TypeFn_<state>,     IfHelper<state, Then, Else>: TypeFn_<Pred::Output, Output = out>,  type Output = out;

• impl<Cond, Then, Else, out> TypeFn_<()> for IfEager<Cond, Then, Else> where     IfEagerHelper<Then, Else>: TypeFn_<Cond, Output = out>,  type Output = out;

• impl<Rhs> TypeFn_<(True, Rhs)> for LogicalOr type Output = True;

• impl<Rhs> TypeFn_<(False, Rhs)> for LogicalOr where     Rhs: TypeFn_<()>,     Rhs::Output: Boolean,  type Output = Rhs::Output;

• impl<Rhs> TypeFn_<(False, Rhs)> for LogicalAnd type Output = False;

• impl<Rhs> TypeFn_<(True, Rhs)> for LogicalAnd where     Rhs: TypeFn_<()>,     Rhs::Output: Boolean,  type Output = Rhs::Output;

• impl<__Self, DefaultVal, Func> TypeFn_<(__Self, DefaultVal, Func)> for FoldLOp where     __Self: FoldL_<DefaultVal, Func>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self, DefaultVal, Func> TypeFn_<(__Self, DefaultVal, Func)> for FoldROp where     __Self: FoldR_<DefaultVal, Func>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self, Func> TypeFn_<(__Self, Func)> for ReduceLOp where     __Self: ReduceL_<Func>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self, Func> TypeFn_<(__Self, Func)> for ReduceROp where     __Self: ReduceR_<Func>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self, Func> TypeFn_<(__Self, Func)> for MapOp where     __Self: Map_<Func>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self, Predicate> TypeFn_<(__Self, Predicate)> for FilterOp where     __Self: Filter_<Predicate>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self, Index> TypeFn_<(__Self, Index)> for RemoveOp where     __Self: Remove_<Index>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self, Index, Value> TypeFn_<(__Self, Index, Value)> for InsertOp where     __Self: Insert_<Index, Value>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self, Value> TypeFn_<(__Self, Value)> for PushOp where     __Self: Push_<Value>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self> TypeFn_<__Self> for PopOp where     __Self: Pop_,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self, Value> TypeFn_<(__Self, Value)> for PushBackOp where     __Self: PushBack_<Value>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self> TypeFn_<__Self> for PopBackOp where     __Self: PopBack_,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self, Value> TypeFn_<(__Self, Value)> for PushFrontOp where     __Self: PushFront_<Value>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self> TypeFn_<__Self> for PopFrontOp where     __Self: PopFront_,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self> TypeFn_<__Self> for LenOp where     __Self: Len_,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self, Value, Repeated> TypeFn_<(__Self, Value, Repeated)> for RepeatOp where     __Self: Repeat_<Value, Repeated>,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<__Self> TypeFn_<__Self> for ReverseOp where     __Self: Reverse_,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<Collection, Element, EqualsElement, Out> TypeFn_<(Collection, Element)> for ContainsOp where     ApplyRhs<ConstEqOp, Element>: TypeIdentity<Type = EqualsElement>,     AnyOp: TypeFn_<(Collection, EqualsElement), Output = Out>,  type Output = Out;

• impl<Collection, Predicate, MappedUnary> TypeFn_<(Collection, Predicate)> for AllOp where     MapRhs<BitAndOp, Predicate>: TypeIdentity<Type = MappedUnary>,     Collection: FoldL_<True, MappedUnary>,  type Output = Collection::Output;

• impl<Collection, Predicate, MappedUnary> TypeFn_<(Collection, Predicate)> for AnyOp where     MapRhs<BitOrOp, Predicate>: TypeIdentity<Type = MappedUnary>,     Collection: FoldL_<False, MappedUnary>,  type Output = Collection::Output;

• impl<Collection, Defaultval, GetRhs, Out> TypeFn_<(Collection, Defaultval)> for LastOrDefaultOp where     ApplyRhs<GetFieldOp, U1>: TypeIdentity<Type = GetRhs>,     Collection: FoldL_<Defaultval, GetRhs, Output = Out>,  type Output = Out;

• impl<__Self> TypeFn_<__Self> for UnwrapOp where     __Self: Unwrap_,     __Self::Output: Sized,  type Output = __Self::Output;

• impl<This, Field> TypeFn_<(This, Field)> for GetFieldOp where     This: GetField_<Field>,     This::Output: Sized,  type Output = This::Output;

• impl<This, Field, Value> TypeFn_<(This, Field, Value)> for SetFieldOp where     This: SetField_<Field, Value>,     This::Output: Sized,  type Output = This::Output;

• impl<Struct, Fields, Value> TypeFn_<(Struct, Fields)> for SetFieldsToOp<Value> where     Fields: FoldL_<Struct, ApplyNth<SetFieldOp, U2, Value>>,  type Output = Fields::Output;

• impl<Struc, FVPairs, Out> TypeFn_<(Struc, FVPairs)> for SetFieldsOp where     FVPairs: FoldL_<Struc, SetFieldValuePair, Output = Out>,  type Output = Out;

• impl<Struc, Field, Value, Out> TypeFn_<(Struc, (Field, Value))> for SetFieldValuePair where     Struc: SetField_<Field, Value, Output = Out>,  type Output = Out;

• impl<This, Field, Mapper, Res0, NewValue, Res2> TypeFn_<(This, Field, Mapper)> for MapFieldOp where     This: GetField_<Field, Output = Res0>,     Mapper: TypeFn_<Res0, Output = NewValue>,     This: SetField_<Field, NewValue, Output = Res2>,  type Output = Res2;

• impl<This, Field, Mapper, NewValue, Out> TypeFn_<(This, Field, Mapper)> for MapIntoFieldOp where     Mapper: TypeFn_<This, Output = NewValue>,     This: SetField_<Field, NewValue, Output = Out>,  type Output = Out;

• impl TypeFn_<PhantomKind> for AssertValidKind type Output = ();

• impl<R> TypeFn_<RuntimeKind<R>> for AssertValidKind type Output = ();

• impl<T, Kind, Params> TypeFn_<Params> for ConstWrapper<T, Kind> where     T: TypeFn_<Params>,  type Output = T::Output;

• impl<OrRes0> TypeFn_<OrRes0> for TNil type Output = OrRes0;

• impl<L0, OrRes0, OrRes1> TypeFn_<OrRes0> for TList<L0, TNil> where     L0: TypeFn_<OrRes0, Output = OrRes1>,  type Output = OrRes1;

• impl<L0, OrRes0, L1, OrRes1, OrRes2> TypeFn_<OrRes0> for TList<L0, TList<L1, TNil>> where     L0: TypeFn_<OrRes0, Output = OrRes1>,     L1: TypeFn_<OrRes1, Output = OrRes2>,  type Output = OrRes2;

• impl<L0, OrRes0, L1, OrRes1, L2, OrRes2, OrRes3> TypeFn_<OrRes0> for TList<L0, TList<L1, TList<L2, TNil>>> where     L0: TypeFn_<OrRes0, Output = OrRes1>,     L1: TypeFn_<OrRes1, Output = OrRes2>,     L2: TypeFn_<OrRes2, Output = OrRes3>,  type Output = OrRes3;

• impl<L0, OrRes0, L1, OrRes1, L2, OrRes2, L3, OrRes3, OrRes4> TypeFn_<OrRes0> for TList<L0, TList<L1, TList<L2, TList<L3, TNil>>>> where     L0: TypeFn_<OrRes0, Output = OrRes1>,     L1: TypeFn_<OrRes1, Output = OrRes2>,     L2: TypeFn_<OrRes2, Output = OrRes3>,     L3: TypeFn_<OrRes3, Output = OrRes4>,  type Output = OrRes4;

• impl<L0, OrRes0, L1, OrRes1, L2, OrRes2, L3, OrRes3, L4, OrRes4, OrRes5> TypeFn_<OrRes0> for TList<L0, TList<L1, TList<L2, TList<L3, TList<L4, TNil>>>>> where     L0: TypeFn_<OrRes0, Output = OrRes1>,     L1: TypeFn_<OrRes1, Output = OrRes2>,     L2: TypeFn_<OrRes2, Output = OrRes3>,     L3: TypeFn_<OrRes3, Output = OrRes4>,     L4: TypeFn_<OrRes4, Output = OrRes5>,  type Output = OrRes5;

• impl<L0, OrRes0, L1, OrRes1, L2, OrRes2, L3, OrRes3, L4, OrRes4, L5, OrRes5, OrRes6> TypeFn_<OrRes0> for TList<L0, TList<L1, TList<L2, TList<L3, TList<L4, TList<L5, TNil>>>>>> where     L0: TypeFn_<OrRes0, Output = OrRes1>,     L1: TypeFn_<OrRes1, Output = OrRes2>,     L2: TypeFn_<OrRes2, Output = OrRes3>,     L3: TypeFn_<OrRes3, Output = OrRes4>,     L4: TypeFn_<OrRes4, Output = OrRes5>,     L5: TypeFn_<OrRes5, Output = OrRes6>,  type Output = OrRes6;

• impl<L0, OrRes0, L1, OrRes1, L2, OrRes2, L3, OrRes3, L4, OrRes4, L5, OrRes5, L6, OrRes6, OrRes7> TypeFn_<OrRes0> for TList<L0, TList<L1, TList<L2, TList<L3, TList<L4, TList<L5, TList<L6, TNil>>>>>>> where     L0: TypeFn_<OrRes0, Output = OrRes1>,     L1: TypeFn_<OrRes1, Output = OrRes2>,     L2: TypeFn_<OrRes2, Output = OrRes3>,     L3: TypeFn_<OrRes3, Output = OrRes4>,     L4: TypeFn_<OrRes4, Output = OrRes5>,     L5: TypeFn_<OrRes5, Output = OrRes6>,     L6: TypeFn_<OrRes6, Output = OrRes7>,  type Output = OrRes7;

• impl<L0, OrRes0, L1, OrRes1, L2, OrRes2, L3, OrRes3, L4, OrRes4, L5, OrRes5, L6, OrRes6, L7, OrRes7, OrRes8, OrRes9, Rem> TypeFn_<OrRes0> for TList<L0, TList<L1, TList<L2, TList<L3, TList<L4, TList<L5, TList<L6, TList<L7, Rem>>>>>>>> where     L0: TypeFn_<OrRes0, Output = OrRes1>,     L1: TypeFn_<OrRes1, Output = OrRes2>,     L2: TypeFn_<OrRes2, Output = OrRes3>,     L3: TypeFn_<OrRes3, Output = OrRes4>,     L4: TypeFn_<OrRes4, Output = OrRes5>,     L5: TypeFn_<OrRes5, Output = OrRes6>,     L6: TypeFn_<OrRes6, Output = OrRes7>,     L7: TypeFn_<OrRes7, Output = OrRes8>,     Rem: TypeFn_<OrRes8, Output = OrRes9>,  type Output = OrRes9;

• impl<T> TypeFn_<T> for AssertConstType where     T: ConstType,  type Output = ();

• impl TypeFn_<None_> for IsSome type Output = False;

• impl<T> TypeFn_<Some_<T>> for IsSome type Output = True;

• impl<V> TypeFn_<Ok_<V>> for IsOk type Output = True;

• impl<V> TypeFn_<Err_<V>> for IsOk type Output = False;

• impl<ThisCC, Op> TypeFn_<(ThisCC, Op, Builtin)> for AllowHelper where     Op: ConstMethod_BuiltinExt,  type Output = ();

• impl<ThisCC, Op> TypeFn_<(ThisCC, Op, RegularExt)> for AllowHelper where     Op: ConstMethod_RegularExt,     ThisCC: AllowedOps<ExtensionMethods = True>,  type Output = ();

• impl<R, N, out, is_0> TypeFn_<R> for IntTypeOfRange where     R: RangeTrait,     R::end: Sub<R::start, Output = N>,     N: ConstEq_<U0, Output = is_0>,     is_0: Boolean,     IntTypeOfHelper: TypeFn_<(is_0, N), Output = out>,  type Output = out;

• impl<R, out, is_0> TypeFn_<R> for IntTypeOfEnd where     R: RangeTrait,     R::end: ConstEq_<U0, Output = is_0>,     is_0: Boolean,     IntTypeOfHelper: TypeFn_<(is_0, R::end), Output = out>,  type Output = out;

• impl TypeFn_<(True, U0)> for IntTypeOfHelper type Output = u8;

• impl<End, n, out> TypeFn_<(False, End)> for IntTypeOfHelper where     End: Sub<U1, Output = n>,     IntTypeOf: TypeFn_<n, Output = out>,  type Output = out;

• impl<N, DivU8, DivU16, DivU32, IsU16, IsU32, IsU64, out> TypeFn_<N> for IntTypeOf where     N: Shr<U8, Output = DivU8>,     DivU8: Shr<U8, Output = DivU16>,     DivU16: Shr<U16, Output = DivU32>,     DivU8: ConstEq_<U0, Output = IsU16>,     DivU16: ConstEq_<U0, Output = IsU32>,     DivU32: ConstEq_<U0, Output = IsU64>,     IntTypeHelper: TypeFn_<(IsU16, IsU32, IsU64), Output = out>,     IsU16: Boolean,     IsU32: Boolean,     IsU64: Boolean,  type Output = out;

• impl TypeFn_<(True, True, True)> for IntTypeHelper type Output = u8;

• impl TypeFn_<(False, True, True)> for IntTypeHelper type Output = u16;

• impl TypeFn_<(False, False, True)> for IntTypeHelper type Output = u32;

• impl TypeFn_<(False, False, False)> for IntTypeHelper type Output = u64;

• impl<Type, FVPairs, InitFVPairs, Out, InitOut> TypeFn_<(Type, FVPairs)> for ConstructFn where     Type: InitializationValues,     FVPairs: Map_<SetInitialized, Output = InitFVPairs>,     SetFieldsOp: TypeFn_<(Type::Uninitialized, FVPairs), Output = Out>,     SetFieldsOp: TypeFn_<(Type::Uninitialized, InitFVPairs), Output = InitOut>,     InitOut: TypeIdentity<Type = Type::Initialized>,  type Output = Out;