Struct frunk::hlist::HCons

pub struct HCons<H, T> {
    pub head: H,
    pub tail: T,
}

Represents the most basic non-empty HList. Its value is held in head while its tail is another HList.

Fields

head: H

tail: T

Implementations

impl<H, T> HCons<H, T>

pub fn pop(self) -> (H, T)

Returns the head of the list and the tail of the list as a tuple2. The original list is consumed

Examples

let h = hlist!("hi");
let (h, tail) = h.pop();
assert_eq!(h, "hi");
assert_eq!(tail, hlist![]);

impl<Head, Tail> HCons<Head, Tail>

pub fn get<T, Index>(&self) -> &T where
    HCons<Head, Tail>: Selector<T, Index>, 

Borrow an element by type from an HList.

Examples

let h = hlist![1i32, 2u32, "hello", true, 42f32];

// Often, type inference can figure out the type you want.
// You can help guide type inference when necessary by
// using type annotations.
let b: &bool = h.get();
if !b { panic!("no way!") };

// If space is tight, you can also use turbofish syntax.
// The Index is still left to type inference by using `_`.
match *h.get::<u32, _>() {
    2 => { },
    _ => panic!("it can't be!!"),
}

pub fn get_mut<T, Index>(&mut self) -> &mut T where
    HCons<Head, Tail>: Selector<T, Index>, 

Mutably borrow an element by type from an HList.

Examples

let mut h = hlist![1i32, true];

// Type inference ensures we fetch the correct type.
*h.get_mut() = false;
*h.get_mut() = 2;
// *h.get_mut() = "neigh";  // Won't compile.

assert_eq!(h, hlist![2i32, false]);

pub fn pluck<T, Index>(
    self
) -> (T, <HCons<Head, Tail> as Plucker<T, Index>>::Remainder) where
    HCons<Head, Tail>: Plucker<T, Index>, 

Remove an element by type from an HList.

The remaining elements are returned along with it.

Examples

let list = hlist![1, "hello", true, 42f32];

// Often, type inference can figure out the target type.
let (b, list): (bool, _) = list.pluck();
assert!(b);

// When type inference will not suffice, you can use a turbofish.
// The Index is still left to type inference by using `_`.
let (s, list) = list.pluck::<i32, _>();

// Each time we plucked, we got back a remainder.
// Let's check what's left:
assert_eq!(list, hlist!["hello", 42.0])

pub fn into_tuple2(
    self
) -> (<HCons<Head, Tail> as IntoTuple2>::HeadType, <HCons<Head, Tail> as IntoTuple2>::TailOutput) where
    HCons<Head, Tail>: IntoTuple2, 

Turns an HList into nested Tuple2s, which are less troublesome to pattern match and have a nicer type signature.

Examples

let h = hlist![1, "hello", true, 42f32];

// We now have a much nicer pattern matching experience
let (first,(second,(third, fourth))) = h.into_tuple2();

assert_eq!(first ,       1);
assert_eq!(second, "hello");
assert_eq!(third ,    true);
assert_eq!(fourth,   42f32);

impl<Head, Tail> HCons<Head, Tail>

pub fn len(&self) -> usize where
    HCons<Head, Tail>: HList, 

Returns the length of a given HList

Examples

let h = hlist![1, "hi"];
assert_eq!(h.len(), 2);

pub fn is_empty(&self) -> bool where
    HCons<Head, Tail>: HList, 

Returns whether a given HList is empty

Examples

let h = hlist![];
assert!(h.is_empty());

pub fn prepend<H>(self, h: H) -> HCons<H, HCons<Head, Tail>> where
    HCons<Head, Tail>: HList, 

Prepend an item to the current HList

Examples

let h1 = hlist![1, "hi"];
let h2 = h1.prepend(true);
let (a, (b, c)) = h2.into_tuple2();
assert_eq!(a, true);
assert_eq!(b, 1);
assert_eq!(c, "hi");

pub fn sculpt<Ts, Indices>(
    self
) -> (Ts, <HCons<Head, Tail> as Sculptor<Ts, Indices>>::Remainder) where
    HCons<Head, Tail>: Sculptor<Ts, Indices>, 

Consume the current HList and return an HList with the requested shape.

sculpt allows us to extract/reshape/scult the current HList into another shape, provided that the requested shape’s types are are contained within the current HList.

The Indices type parameter allows the compiler to figure out that Ts and Self can be morphed into each other.

Examples

let h = hlist![9000, "joe", 41f32, true];
let (reshaped, remainder): (Hlist![f32, i32, &str], _) = h.sculpt();
assert_eq!(reshaped, hlist![41f32, 9000, "joe"]);
assert_eq!(remainder, hlist![true]);

pub fn into_reverse(self) -> <HCons<Head, Tail> as IntoReverse>::Output where
    HCons<Head, Tail>: IntoReverse, 

Reverse the HList.

Examples

assert_eq!(hlist![].into_reverse(), hlist![]);

assert_eq!(
    hlist![1, "hello", true, 42f32].into_reverse(),
    hlist![42f32, true, "hello", 1],
)

pub fn to_ref<'a>(&'a self) -> <HCons<Head, Tail> as ToRef<'a>>::Output where
    HCons<Head, Tail>: ToRef<'a>, 

Return an HList where the contents are references to the original HList on which this method was called.

Examples

assert_eq!(hlist![].to_ref(), hlist![]);

assert_eq!(hlist![1, true].to_ref(), hlist![&1, &true]);

pub fn to_mut<'a>(&'a mut self) -> <HCons<Head, Tail> as ToMut<'a>>::Output where
    HCons<Head, Tail>: ToMut<'a>, 

Return an HList where the contents are mutable references to the original HList on which this method was called.

Examples

assert_eq!(hlist![].to_mut(), hlist![]);

assert_eq!(hlist![1, true].to_mut(), hlist![&mut 1, &mut true]);

pub fn map<F>(self, mapper: F) -> <HCons<Head, Tail> as HMappable<F>>::Output where
    HCons<Head, Tail>: HMappable<F>, 

Apply a function to each element of an HList.

This transforms some Hlist![A, B, C, ..., E] into some Hlist![T, U, V, ..., Z]. A variety of types are supported for the folder argument:

• An hlist![] of closures (one for each element).
• A single closure (for mapping an HList that is homogenous).
• A single Poly.

Examples

use ::frunk::HNil;

assert_eq!(HNil.map(HNil), HNil);

let h = hlist![1, false, 42f32];

// Sadly we need to help the compiler understand the bool type in our mapper

let mapped = h.to_ref().map(hlist![
    |&n| n + 1,
    |b: &bool| !b,
    |&f| f + 1f32]);
assert_eq!(mapped, hlist![2, true, 43f32]);

// There is also a value-consuming version that passes values to your functions
// instead of just references:

let mapped2 = h.map(hlist![
    |n| n + 3,
    |b: bool| !b,
    |f| f + 8959f32]);
assert_eq!(mapped2, hlist![4, true, 9001f32]);

pub fn zip<Other>(
    self,
    other: Other
) -> <HCons<Head, Tail> as HZippable<Other>>::Zipped where
    HCons<Head, Tail>: HZippable<Other>, 

Zip two HLists together.

This zips a Hlist![A1, B1, ..., C1] with a Hlist![A2, B2, ..., C2] to make a Hlist![(A1, A2), (B1, B2), ..., (C1, C2)]

Example

use ::frunk::HNil;

assert_eq!(HNil.zip(HNil), HNil);

let h1 = hlist![1, false, 42f32];
let h2 = hlist![true, "foo", 2];

let zipped = h1.zip(h2);
assert_eq!(zipped, hlist![
    (1, true),
    (false, "foo"),
    (42f32, 2),
]);

pub fn foldl<Folder, Acc>(
    self,
    folder: Folder,
    acc: Acc
) -> <HCons<Head, Tail> as HFoldLeftable<Folder, Acc>>::Output where
    HCons<Head, Tail>: HFoldLeftable<Folder, Acc>, 

Perform a left fold over an HList.

This transforms some Hlist![A, B, C, ..., E] into a single value by visiting all of the elements in left-to-right order. A variety of types are supported for the mapper argument:

• An hlist![] of closures (one for each element).
• A single closure (for folding an HList that is homogenous).
• A single Poly.

The accumulator can freely change type over the course of the call. When called with a list of N functions, an expanded form of the implementation with type annotations might look something like this:

let acc: Acc0 = init_value;
let acc: Acc1 = f1(acc, x1);
let acc: Acc2 = f2(acc, x2);
let acc: Acc3 = f3(acc, x3);
...
let acc: AccN = fN(acc, xN);
acc

Examples

let nil = hlist![];

assert_eq!(nil.foldl(hlist![], 0), 0);

let h = hlist![1, false, 42f32];

let folded = h.to_ref().foldl(
    hlist![
        |acc, &i| i + acc,
        |acc, b: &bool| if !b && acc > 42 { 9000f32 } else { 0f32 },
        |acc, &f| f + acc
    ],
    1
);

assert_eq!(42f32, folded);

// There is also a value-consuming version that passes values to your folding
// functions instead of just references:

let folded2 = h.foldl(
    hlist![
        |acc, i| i + acc,
        |acc, b: bool| if !b && acc > 42 { 9000f32 } else { 0f32 },
        |acc, f| f + acc
    ],
    8918
);

assert_eq!(9042f32, folded2)

pub fn foldr<Folder, Init>(
    self,
    folder: Folder,
    init: Init
) -> <HCons<Head, Tail> as HFoldRightable<Folder, Init>>::Output where
    HCons<Head, Tail>: HFoldRightable<Folder, Init>, 

Perform a right fold over an HList.

This transforms some Hlist![A, B, C, ..., E] into a single value by visiting all of the elements in reverse order. A variety of types are supported for the mapper argument:

• An hlist![] of closures (one for each element).
• A single closure (for folding an HList that is homogenous), taken by reference.
• A single Poly.

The accumulator can freely change type over the course of the call.

Comparison to foldl

While the order of element traversal in foldl may seem more natural, foldr does have its use cases, in particular when it is used to build something that reflects the structure of the original HList (such as folding an HList of Options into an Option of an HList). An implementation of such a function using foldl will tend to reverse the list, while foldr will tend to preserve its order.

The reason for this is because foldr performs what is known as “structural induction;” it can be understood as follows:

• Write out the HList in terms of h_cons and HNil.
• Substitute each h_cons with a function, and substitute HNil with init

the list:
    h_cons(x1, h_cons(x2, h_cons(x3, ...h_cons(xN, HNil))...)))

becomes:
       f1( x1,    f2( x2,    f3( x3, ...   fN( xN, init))...)))

Examples

let nil = hlist![];

assert_eq!(nil.foldr(hlist![], 0), 0);

let h = hlist![1, false, 42f32];

let folded = h.foldr(
    hlist![
        |i, acc| i + acc,
        |b: bool, acc| if !b && acc > 42f32 { 9000 } else { 0 },
        |f, acc| f + acc
    ],
    1f32
);

assert_eq!(9001, folded)

Trait Implementations

impl<H, T, RHS> Add<RHS> for HCons<H, T> where
    T: Add<RHS>,
    RHS: HList, 

type Output = HCons<H, <T as Add<RHS>>::Output>

The resulting type after applying the + operator.

pub fn add(self, rhs: RHS) -> <HCons<H, T> as Add<RHS>>::Output

Performs the + operation.

impl<K, V, Tail> ByNameFieldPlucker<K, Here> for HCons<Field<K, V>, Tail>

Implementation when the pluck target key is in the head.

type TargetValue = V

type Remainder = Tail

pub fn pluck_by_name(
    self
) -> (Field<K, <HCons<Field<K, V>, Tail> as ByNameFieldPlucker<K, Here>>::TargetValue>, <HCons<Field<K, V>, Tail> as ByNameFieldPlucker<K, Here>>::Remainder)

Returns a pair consisting of the value pointed to by the target key and the remainder.

impl<Head, Tail, K, TailIndex> ByNameFieldPlucker<K, There<TailIndex>> for HCons<Head, Tail> where
    Tail: ByNameFieldPlucker<K, TailIndex>, 

Implementation when the pluck target key is in the tail.

type TargetValue = <Tail as ByNameFieldPlucker<K, TailIndex>>::TargetValue

type Remainder = HCons<Head, <Tail as ByNameFieldPlucker<K, TailIndex>>::Remainder>

pub fn pluck_by_name(
    self
) -> (Field<K, <HCons<Head, Tail> as ByNameFieldPlucker<K, There<TailIndex>>>::TargetValue>, <HCons<Head, Tail> as ByNameFieldPlucker<K, There<TailIndex>>>::Remainder)

Returns a pair consisting of the value pointed to by the target key and the remainder.

impl<H, T> Clone for HCons<H, T> where
    T: Clone,
    H: Clone, 

pub fn clone(&self) -> HCons<H, T>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Head, Tail, Out, NHead, NTail> CoproductEmbedder<Out, HCons<NHead, NTail>> for Coproduct<Head, Tail> where
    Tail: CoproductEmbedder<Out, NTail>,
    Out: CoprodInjector<Head, NHead>, 

pub fn embed(self) -> Out

Convert a coproduct into another that can hold its variants.

impl<F, R, FTail, CH, CTail> CoproductFoldable<HCons<F, FTail>, R> for Coproduct<CH, CTail> where
    F: FnOnce(CH) -> R,
    CTail: CoproductFoldable<FTail, R>, 

pub fn fold(self, f: HCons<F, FTail>) -> R

Use functions to fold a coproduct into a single value.

impl<Choices, THead, TTail, NHead, NTail, Rem> CoproductSubsetter<Coproduct<THead, TTail>, HCons<NHead, NTail>> for Choices where
    Rem: CoproductSubsetter<TTail, NTail>,
    Choices: CoprodUninjector<THead, NHead, Remainder = Rem>, 

type Remainder = <Rem as CoproductSubsetter<TTail, NTail>>::Remainder

pub fn subset(
    self
) -> Result<Coproduct<THead, TTail>, <Choices as CoproductSubsetter<Coproduct<THead, TTail>, HCons<NHead, NTail>>>::Remainder>

Attempt to extract a value from a subset of the types.

impl<H, T> Copy for HCons<H, T> where
    T: Copy,
    H: Copy, 

impl<H, T> Debug for HCons<H, T> where
    T: Debug,
    H: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T, Tail> Default for HCons<T, Tail> where
    T: Default,
    Tail: Default + HList, 

pub fn default() -> HCons<T, Tail>

Returns the “default value” for a type.

impl<H, T> Eq for HCons<H, T> where
    T: Eq,
    H: Eq, 

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9> From<(F1, F2, F3, F4, F5, F6, F7, F8, F9)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8, F9)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8> From<(F1, F2, F3, F4, F5, F6, F7, F8)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7, F8)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7> From<(F1, F2, F3, F4, F5, F6, F7)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6, F7)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6> From<(F1, F2, F3, F4, F5, F6)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>, 

pub fn from(
    f: (F1, F2, F3, F4, F5, F6)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5> From<(F1, F2, F3, F4, F5)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HNil>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>, 

pub fn from(
    f: (F1, F2, F3, F4, F5)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HNil>>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3, F4, T4> From<(F1, F2, F3, F4)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HNil>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>,
    T4: From<F4>, 

pub fn from(
    f: (F1, F2, F3, F4)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HNil>>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2, F3, T3> From<(F1, F2, F3)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HNil>>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>,
    T3: From<F3>, 

pub fn from(f: (F1, F2, F3)) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HNil>>>>

Performs the conversion.

impl<T0, F1, T1, F2, T2> From<(F1, F2)> for HCons<T0, HCons<T1, HCons<T2, HNil>>> where
    T2: From<F2>,
    T0: Default,
    T1: From<F1>, 

pub fn from(f: (F1, F2)) -> HCons<T0, HCons<T1, HCons<T2, HNil>>>

Performs the conversion.

impl<T0, F1, T1> From<(F1,)> for HCons<T0, HCons<T1, HNil>> where
    T0: Default,
    T1: From<F1>, 

pub fn from(f: (F1,)) -> HCons<T0, HCons<T1, HNil>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F10, F11, F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F10, F11, F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F10, F11, F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F10, F11, F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F10, F11, F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F10, F11, F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F10, F11, F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F10, F11, F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14> From<(F10, F11, F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F10, F11, F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12, F13, T13> From<(F10, F11, F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F10, F11, F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11, F12, T12> From<(F10, F11, F12)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>, 

pub fn from(
    f: (F10, F11, F12)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10, F11, T11> From<(F10, F11)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>,
    T11: From<F11>, 

pub fn from(
    f: (F10, F11)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F10, T10> From<(F10,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: From<F10>, 

pub fn from(
    f: (F10,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F11, F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F11, F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F11, F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F11, F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F11, F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F11, F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F11, F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F11, F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F11, F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F11, F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12, F13, T13, F14, T14> From<(F11, F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F11, F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12, F13, T13> From<(F11, F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F11, F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11, F12, T12> From<(F11, F12)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>,
    T12: From<F12>, 

pub fn from(
    f: (F11, F12)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F11, T11> From<(F11,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: From<F11>, 

pub fn from(
    f: (F11,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12, F13, T13, F14, T14> From<(F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12, F13, T13> From<(F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F12, T12> From<(F12,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: From<F12>, 

pub fn from(
    f: (F12,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F13, T13, F14, T14, F15, T15> From<(F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F13, T13, F14, T14> From<(F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F13, T13> From<(F13,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: From<F13>, 

pub fn from(
    f: (F13,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F14, T14, F15, T15, F16, T16> From<(F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F14, T14, F15, T15> From<(F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F14, T14> From<(F14,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: From<F14>, 

pub fn from(
    f: (F14,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F15, T15, F16, T16, F17, T17> From<(F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F15, T15, F16, T16> From<(F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F15, T15> From<(F15,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: From<F15>, 

pub fn from(
    f: (F15,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F16, T16, F17, T17, F18, T18> From<(F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F16, T16, F17, T17> From<(F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F16, T16> From<(F16,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: From<F16>, 

pub fn from(
    f: (F16,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F17, T17, F18, T18, F19, T19> From<(F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F17, T17, F18, T18> From<(F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F17, T17> From<(F17,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: From<F17>, 

pub fn from(
    f: (F17,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F18, T18, F19, T19, F20, T20> From<(F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F18, T18, F19, T19> From<(F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F18, T18> From<(F18,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: From<F18>, 

pub fn from(
    f: (F18,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F19, T19, F20, T20, F21, T21> From<(F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F19, T19, F20, T20> From<(F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F19, T19> From<(F19,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: From<F19>, 

pub fn from(
    f: (F19,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10> From<(F2, F3, F4, F5, F6, F7, F8, F9, F10)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9, F10)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9> From<(F2, F3, F4, F5, F6, F7, F8, F9)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8, F9)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8> From<(F2, F3, F4, F5, F6, F7, F8)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7, F8)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7> From<(F2, F3, F4, F5, F6, F7)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>, 

pub fn from(
    f: (F2, F3, F4, F5, F6, F7)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6> From<(F2, F3, F4, F5, F6)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>, 

pub fn from(
    f: (F2, F3, F4, F5, F6)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4, F5, T5> From<(F2, F3, F4, F5)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HNil>>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>, 

pub fn from(
    f: (F2, F3, F4, F5)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HNil>>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3, F4, T4> From<(F2, F3, F4)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HNil>>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>, 

pub fn from(
    f: (F2, F3, F4)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HNil>>>>>

Performs the conversion.

impl<T0, T1, F2, T2, F3, T3> From<(F2, F3)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HNil>>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default,
    T3: From<F3>, 

pub fn from(f: (F2, F3)) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HNil>>>>

Performs the conversion.

impl<T0, T1, F2, T2> From<(F2,)> for HCons<T0, HCons<T1, HCons<T2, HNil>>> where
    T2: From<F2>,
    T0: Default,
    T1: Default, 

pub fn from(f: (F2,)) -> HCons<T0, HCons<T1, HCons<T2, HNil>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: Default,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F20, T20, F21, T21, F22, T22> From<(F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: Default,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F20, T20, F21, T21> From<(F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: Default,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F20, T20> From<(F20,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: Default,
    T20: From<F20>, 

pub fn from(
    f: (F20,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F21, T21, F22, T22, F23, T23> From<(F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: Default,
    T20: Default,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F21, T21, F22, T22> From<(F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: Default,
    T20: Default,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F21, T21> From<(F21,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: Default,
    T20: Default,
    T21: From<F21>, 

pub fn from(
    f: (F21,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, F22, T22, F23, T23> From<(F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: Default,
    T20: Default,
    T21: Default,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, F22, T22> From<(F22,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: Default,
    T20: Default,
    T21: Default,
    T22: From<F22>, 

pub fn from(
    f: (F22,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, F23, T23> From<(F23,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: Default,
    T10: Default,
    T11: Default,
    T12: Default,
    T13: Default,
    T14: Default,
    T15: Default,
    T16: Default,
    T17: Default,
    T18: Default,
    T19: Default,
    T20: Default,
    T21: Default,
    T22: Default,
    T23: From<F23>, 

pub fn from(
    f: (F23,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11> From<(F3, F4, F5, F6, F7, F8, F9, F10, F11)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10, F11)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10> From<(F3, F4, F5, F6, F7, F8, F9, F10)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9, F10)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9> From<(F3, F4, F5, F6, F7, F8, F9)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8, F9)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8> From<(F3, F4, F5, F6, F7, F8)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>, 

pub fn from(
    f: (F3, F4, F5, F6, F7, F8)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6, F7, T7> From<(F3, F4, F5, F6, F7)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>, 

pub fn from(
    f: (F3, F4, F5, F6, F7)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5, F6, T6> From<(F3, F4, F5, F6)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>, 

pub fn from(
    f: (F3, F4, F5, F6)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4, F5, T5> From<(F3, F4, F5)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HNil>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>,
    T5: From<F5>, 

pub fn from(
    f: (F3, F4, F5)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HNil>>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3, F4, T4> From<(F3, F4)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HNil>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>,
    T4: From<F4>, 

pub fn from(
    f: (F3, F4)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HNil>>>>>

Performs the conversion.

impl<T0, T1, T2, F3, T3> From<(F3,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HNil>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: From<F3>, 

pub fn from(f: (F3,)) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HNil>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12> From<(F4, F5, F6, F7, F8, F9, F10, F11, F12)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11, F12)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11> From<(F4, F5, F6, F7, F8, F9, F10, F11)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10, F11)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10> From<(F4, F5, F6, F7, F8, F9, F10)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9, F10)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9> From<(F4, F5, F6, F7, F8, F9)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>, 

pub fn from(
    f: (F4, F5, F6, F7, F8, F9)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7, F8, T8> From<(F4, F5, F6, F7, F8)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>, 

pub fn from(
    f: (F4, F5, F6, F7, F8)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6, F7, T7> From<(F4, F5, F6, F7)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>, 

pub fn from(
    f: (F4, F5, F6, F7)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5, F6, T6> From<(F4, F5, F6)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>,
    T6: From<F6>, 

pub fn from(
    f: (F4, F5, F6)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4, F5, T5> From<(F4, F5)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HNil>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>,
    T5: From<F5>, 

pub fn from(
    f: (F4, F5)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HNil>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, F4, T4> From<(F4,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HNil>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: From<F4>, 

pub fn from(
    f: (F4,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HNil>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14> From<(F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13> From<(F5, F6, F7, F8, F9, F10, F11, F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12> From<(F5, F6, F7, F8, F9, F10, F11, F12)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11, F12)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11> From<(F5, F6, F7, F8, F9, F10, F11)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10, F11)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10> From<(F5, F6, F7, F8, F9, F10)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>, 

pub fn from(
    f: (F5, F6, F7, F8, F9, F10)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8, F9, T9> From<(F5, F6, F7, F8, F9)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>, 

pub fn from(
    f: (F5, F6, F7, F8, F9)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7, F8, T8> From<(F5, F6, F7, F8)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>, 

pub fn from(
    f: (F5, F6, F7, F8)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6, F7, T7> From<(F5, F6, F7)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>,
    T7: From<F7>, 

pub fn from(
    f: (F5, F6, F7)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5, F6, T6> From<(F5, F6)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>,
    T6: From<F6>, 

pub fn from(
    f: (F5, F6)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, F5, T5> From<(F5,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HNil>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: From<F5>, 

pub fn from(
    f: (F5,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HNil>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14> From<(F6, F7, F8, F9, F10, F11, F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13> From<(F6, F7, F8, F9, F10, F11, F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12> From<(F6, F7, F8, F9, F10, F11, F12)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11, F12)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11> From<(F6, F7, F8, F9, F10, F11)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>, 

pub fn from(
    f: (F6, F7, F8, F9, F10, F11)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9, F10, T10> From<(F6, F7, F8, F9, F10)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>, 

pub fn from(
    f: (F6, F7, F8, F9, F10)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8, F9, T9> From<(F6, F7, F8, F9)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>, 

pub fn from(
    f: (F6, F7, F8, F9)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7, F8, T8> From<(F6, F7, F8)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>,
    T8: From<F8>, 

pub fn from(
    f: (F6, F7, F8)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6, F7, T7> From<(F6, F7)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>,
    T7: From<F7>, 

pub fn from(
    f: (F6, F7)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, F6, T6> From<(F6,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: From<F6>, 

pub fn from(
    f: (F6,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HNil>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F7, F8, F9, F10, F11, F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14> From<(F7, F8, F9, F10, F11, F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13> From<(F7, F8, F9, F10, F11, F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12> From<(F7, F8, F9, F10, F11, F12)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>, 

pub fn from(
    f: (F7, F8, F9, F10, F11, F12)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10, F11, T11> From<(F7, F8, F9, F10, F11)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>, 

pub fn from(
    f: (F7, F8, F9, F10, F11)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9, F10, T10> From<(F7, F8, F9, F10)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>, 

pub fn from(
    f: (F7, F8, F9, F10)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8, F9, T9> From<(F7, F8, F9)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>,
    T9: From<F9>, 

pub fn from(
    f: (F7, F8, F9)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7, F8, T8> From<(F7, F8)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>,
    T8: From<F8>, 

pub fn from(
    f: (F7, F8)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, F7, T7> From<(F7,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: From<F7>, 

pub fn from(
    f: (F7,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HNil>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F8, F9, F10, F11, F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F8, F9, F10, F11, F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F8, F9, F10, F11, F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F8, F9, F10, F11, F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14> From<(F8, F9, F10, F11, F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F8, F9, F10, F11, F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13> From<(F8, F9, F10, F11, F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F8, F9, F10, F11, F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11, F12, T12> From<(F8, F9, F10, F11, F12)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>, 

pub fn from(
    f: (F8, F9, F10, F11, F12)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10, F11, T11> From<(F8, F9, F10, F11)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>, 

pub fn from(
    f: (F8, F9, F10, F11)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9, F10, T10> From<(F8, F9, F10)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>,
    T10: From<F10>, 

pub fn from(
    f: (F8, F9, F10)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8, F9, T9> From<(F8, F9)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>,
    T9: From<F9>, 

pub fn from(
    f: (F8, F9)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, F8, T8> From<(F8,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: From<F8>, 

pub fn from(
    f: (F8,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HNil>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22, F23, T23> From<(F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>,
    T23: From<F23>, 

pub fn from(
    f: (F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HCons<T23, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21, F22, T22> From<(F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>,
    T22: From<F22>, 

pub fn from(
    f: (F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HCons<T22, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20, F21, T21> From<(F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>,
    T21: From<F21>, 

pub fn from(
    f: (F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HCons<T21, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19, F20, T20> From<(F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>,
    T20: From<F20>, 

pub fn from(
    f: (F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HCons<T20, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18, F19, T19> From<(F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>,
    T19: From<F19>, 

pub fn from(
    f: (F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HCons<T19, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17, F18, T18> From<(F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>,
    T18: From<F18>, 

pub fn from(
    f: (F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HCons<T18, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16, F17, T17> From<(F9, F10, F11, F12, F13, F14, F15, F16, F17)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>,
    T17: From<F17>, 

pub fn from(
    f: (F9, F10, F11, F12, F13, F14, F15, F16, F17)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HCons<T17, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15, F16, T16> From<(F9, F10, F11, F12, F13, F14, F15, F16)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>,
    T16: From<F16>, 

pub fn from(
    f: (F9, F10, F11, F12, F13, F14, F15, F16)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HCons<T16, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14, F15, T15> From<(F9, F10, F11, F12, F13, F14, F15)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>,
    T15: From<F15>, 

pub fn from(
    f: (F9, F10, F11, F12, F13, F14, F15)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HCons<T15, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13, F14, T14> From<(F9, F10, F11, F12, F13, F14)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>,
    T14: From<F14>, 

pub fn from(
    f: (F9, F10, F11, F12, F13, F14)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HCons<T14, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12, F13, T13> From<(F9, F10, F11, F12, F13)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>,
    T13: From<F13>, 

pub fn from(
    f: (F9, F10, F11, F12, F13)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HCons<T13, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11, F12, T12> From<(F9, F10, F11, F12)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>,
    T12: From<F12>, 

pub fn from(
    f: (F9, F10, F11, F12)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HCons<T12, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10, F11, T11> From<(F9, F10, F11)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>,
    T11: From<F11>, 

pub fn from(
    f: (F9, F10, F11)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HCons<T11, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9, F10, T10> From<(F9, F10)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>,
    T10: From<F10>, 

pub fn from(
    f: (F9, F10)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HCons<T10, HNil>>>>>>>>>>>

Performs the conversion.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, F9, T9> From<(F9,)> for HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>> where
    T2: Default,
    T0: Default,
    T1: Default,
    T3: Default,
    T4: Default,
    T5: Default,
    T6: Default,
    T7: Default,
    T8: Default,
    T9: From<F9>, 

pub fn from(
    f: (F9,)
) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4, HCons<T5, HCons<T6, HCons<T7, HCons<T8, HCons<T9, HNil>>>>>>>>>>

Performs the conversion.

impl<T0> From<(T0,)> for HCons<T0, HNil>

pub fn from(tup: (T0,)) -> HCons<T0, HNil>

Performs the conversion.

impl<T1, T0> From<(T1, T0)> for HCons<T1, HCons<T0, HNil>>

pub fn from(tup: (T1, T0)) -> HCons<T1, HCons<T0, HNil>>

Performs the conversion.

impl<T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>

pub fn from(
    tup: (T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>

Performs the conversion.

impl<T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>

pub fn from(
    tup: (T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>

Performs the conversion.

impl<T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>

pub fn from(
    tup: (T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>

Performs the conversion.

impl<T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>

pub fn from(
    tup: (T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>

Performs the conversion.

impl<T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>

pub fn from(
    tup: (T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>

Performs the conversion.

impl<T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>

pub fn from(
    tup: (T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>

pub fn from(
    tup: (T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>

pub fn from(
    tup: (T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>

pub fn from(
    tup: (T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>

pub fn from(
    tup: (T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T2, T1, T0> From<(T2, T1, T0)> for HCons<T2, HCons<T1, HCons<T0, HNil>>>

pub fn from(tup: (T2, T1, T0)) -> HCons<T2, HCons<T1, HCons<T0, HNil>>>

Performs the conversion.

impl<T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>

pub fn from(
    tup: (T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>

pub fn from(
    tup: (T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T22, HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>>

pub fn from(
    tup: (T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T22, HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T23, T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T23, T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T23, HCons<T22, HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>>>

pub fn from(
    tup: (T23, T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T23, HCons<T22, HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>>>

Performs the conversion.

impl<T3, T2, T1, T0> From<(T3, T2, T1, T0)> for HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>

pub fn from(
    tup: (T3, T2, T1, T0)
) -> HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>

Performs the conversion.

impl<T4, T3, T2, T1, T0> From<(T4, T3, T2, T1, T0)> for HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>

pub fn from(
    tup: (T4, T3, T2, T1, T0)
) -> HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>

Performs the conversion.

impl<T5, T4, T3, T2, T1, T0> From<(T5, T4, T3, T2, T1, T0)> for HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>

pub fn from(
    tup: (T5, T4, T3, T2, T1, T0)
) -> HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>

Performs the conversion.

impl<T6, T5, T4, T3, T2, T1, T0> From<(T6, T5, T4, T3, T2, T1, T0)> for HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>

pub fn from(
    tup: (T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>

Performs the conversion.

impl<T7, T6, T5, T4, T3, T2, T1, T0> From<(T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>

pub fn from(
    tup: (T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>

Performs the conversion.

impl<T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>

pub fn from(
    tup: (T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>

Performs the conversion.

impl<T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> From<(T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>

pub fn from(
    tup: (T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)
) -> HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>

Performs the conversion.

impl<F, H, Tail, Acc> HFoldLeftable<F, Acc> for HCons<H, Tail> where
    F: Fn(Acc, H) -> Acc,
    Tail: HFoldLeftable<F, Acc>, 

Implementation for folding over an HList using a single function that can handle all cases

let h = hlist![1, 2, 3, 4, 5];

let r: isize = h.foldl(|acc, next| acc + next, 0);
assert_eq!(r, 15);

type Output = <Tail as HFoldLeftable<F, Acc>>::Output

pub fn foldl(
    self,
    f: F,
    acc: Acc
) -> <HCons<H, Tail> as HFoldLeftable<F, Acc>>::Output

Perform a left fold over an HList.

impl<F, R, FTail, H, Tail, Acc> HFoldLeftable<HCons<F, FTail>, Acc> for HCons<H, Tail> where
    F: FnOnce(Acc, H) -> R,
    Tail: HFoldLeftable<FTail, R>, 

type Output = <Tail as HFoldLeftable<FTail, R>>::Output

pub fn foldl(
    self,
    folder: HCons<F, FTail>,
    acc: Acc
) -> <HCons<H, Tail> as HFoldLeftable<HCons<F, FTail>, Acc>>::Output

Perform a left fold over an HList.

impl<P, R, H, Tail, Acc> HFoldLeftable<Poly<P>, Acc> for HCons<H, Tail> where
    P: Func<(Acc, H), Output = R>,
    Tail: HFoldLeftable<Poly<P>, R>, 

type Output = <Tail as HFoldLeftable<Poly<P>, R>>::Output

pub fn foldl(
    self,
    poly: Poly<P>,
    acc: Acc
) -> <HCons<H, Tail> as HFoldLeftable<Poly<P>, Acc>>::Output

Perform a left fold over an HList.

impl<'a, F, R, H, Tail, Init> HFoldRightable<&'a F, Init> for HCons<H, Tail> where
    F: Fn(H, <Tail as HFoldRightable<&'a F, Init>>::Output) -> R,
    Tail: HFoldRightable<&'a F, Init>, 

type Output = R

pub fn foldr(
    self,
    folder: &'a F,
    init: Init
) -> <HCons<H, Tail> as HFoldRightable<&'a F, Init>>::Output

Perform a right fold over an HList.

impl<F, FolderHeadR, FolderTail, H, Tail, Init> HFoldRightable<HCons<F, FolderTail>, Init> for HCons<H, Tail> where
    F: FnOnce(H, <Tail as HFoldRightable<FolderTail, Init>>::Output) -> FolderHeadR,
    Tail: HFoldRightable<FolderTail, Init>, 

type Output = FolderHeadR

pub fn foldr(
    self,
    folder: HCons<F, FolderTail>,
    init: Init
) -> <HCons<H, Tail> as HFoldRightable<HCons<F, FolderTail>, Init>>::Output

Perform a right fold over an HList.

impl<P, R, H, Tail, Init> HFoldRightable<Poly<P>, Init> for HCons<H, Tail> where
    P: Func<(H, <Tail as HFoldRightable<Poly<P>, Init>>::Output), Output = R>,
    Tail: HFoldRightable<Poly<P>, Init>, 

type Output = R

pub fn foldr(
    self,
    poly: Poly<P>,
    init: Init
) -> <HCons<H, Tail> as HFoldRightable<Poly<P>, Init>>::Output

Perform a right fold over an HList.

impl<H, T> HList for HCons<H, T> where
    T: HList, 

pub const LEN: usize

Returns the length of a given HList type without making use of any references, or in fact, any values at all.

pub fn static_len() -> usize

👎 Deprecated since 0.1.31:

Please use LEN instead

Returns the length of a given HList type without making use of any references, or in fact, any values at all.

pub fn length(&self) -> u32

👎 Deprecated since 0.1.30:

Please use len() or static_len() instead.

pub fn len(&self) -> usize

Returns the length of a given HList

pub fn is_empty(&self) -> bool

Returns whether a given HList is empty

pub fn prepend<H>(self, h: H) -> HCons<H, Self>

Prepends an item to the current HList

impl<F, R, H, Tail> HMappable<F> for HCons<H, Tail> where
    F: Fn(H) -> R,
    Tail: HMappable<F>, 

type Output = HCons<R, <Tail as HMappable<F>>::Output>

pub fn map(self, f: F) -> <HCons<H, Tail> as HMappable<F>>::Output

Apply a function to each element of an HList.

impl<F, R, MapperTail, H, Tail> HMappable<HCons<F, MapperTail>> for HCons<H, Tail> where
    F: FnOnce(H) -> R,
    Tail: HMappable<MapperTail>, 

type Output = HCons<R, <Tail as HMappable<MapperTail>>::Output>

pub fn map(
    self,
    mapper: HCons<F, MapperTail>
) -> <HCons<H, Tail> as HMappable<HCons<F, MapperTail>>>::Output

Apply a function to each element of an HList.

impl<P, H, Tail> HMappable<Poly<P>> for HCons<H, Tail> where
    P: Func<H>,
    Tail: HMappable<Poly<P>>, 

type Output = HCons<<P as Func<H>>::Output, <Tail as HMappable<Poly<P>>>::Output>

pub fn map(
    self,
    poly: Poly<P>
) -> <HCons<H, Tail> as HMappable<Poly<P>>>::Output

Apply a function to each element of an HList.

impl<H1, T1, H2, T2> HZippable<HCons<H2, T2>> for HCons<H1, T1> where
    T1: HZippable<T2>, 

type Zipped = HCons<(H1, H2), <T1 as HZippable<T2>>::Zipped>

pub fn zip(
    self,
    other: HCons<H2, T2>
) -> <HCons<H1, T1> as HZippable<HCons<H2, T2>>>::Zipped

Zip this HList with another one.

impl<H, T> Hash for HCons<H, T> where
    T: Hash,
    H: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T0> Into<(T0,)> for HCons<T0, HNil>

pub fn into(self) -> (T0,)

Performs the conversion.

impl<T1, T0> Into<(T1, T0)> for HCons<T1, HCons<T0, HNil>>

pub fn into(self) -> (T1, T0)

Performs the conversion.

impl<T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>

pub fn into(self) -> (T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>

pub fn into(self) -> (T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>

pub fn into(self) -> (T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>

pub fn into(
    self
) -> (T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>

pub fn into(
    self
) -> (T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>

pub fn into(
    self
) -> (T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>

pub fn into(
    self
) -> (T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>

pub fn into(
    self
) -> (T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>

pub fn into(
    self
) -> (T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>

pub fn into(
    self
) -> (T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T2, T1, T0> Into<(T2, T1, T0)> for HCons<T2, HCons<T1, HCons<T0, HNil>>>

pub fn into(self) -> (T2, T1, T0)

Performs the conversion.

impl<T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>

pub fn into(
    self
) -> (T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>

pub fn into(
    self
) -> (T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T22, HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>>

pub fn into(
    self
) -> (T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T23, T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T23, T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T23, HCons<T22, HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>>>

pub fn into(
    self
) -> (T23, T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T3, T2, T1, T0> Into<(T3, T2, T1, T0)> for HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>

pub fn into(self) -> (T3, T2, T1, T0)

Performs the conversion.

impl<T4, T3, T2, T1, T0> Into<(T4, T3, T2, T1, T0)> for HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>

pub fn into(self) -> (T4, T3, T2, T1, T0)

Performs the conversion.

impl<T5, T4, T3, T2, T1, T0> Into<(T5, T4, T3, T2, T1, T0)> for HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>

pub fn into(self) -> (T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T6, T5, T4, T3, T2, T1, T0> Into<(T6, T5, T4, T3, T2, T1, T0)> for HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>

pub fn into(self) -> (T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T7, T6, T5, T4, T3, T2, T1, T0> Into<(T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>

pub fn into(self) -> (T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>

pub fn into(self) -> (T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<T9, T8, T7, T6, T5, T4, T3, T2, T1, T0> Into<(T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)> for HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>

pub fn into(self) -> (T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)

Performs the conversion.

impl<H, Tail> Into<Vec<H, Global>> for HCons<H, Tail> where
    Tail: Into<Vec<H, Global>> + HList, 

pub fn into(self) -> Vec<H, Global>

Performs the conversion.

impl<H, Tail> IntoReverse for HCons<H, Tail> where
    Tail: IntoReverse,
    <Tail as IntoReverse>::Output: Add<HCons<H, HNil>>, 

type Output = <<Tail as IntoReverse>::Output as Add<HCons<H, HNil>>>::Output

pub fn into_reverse(self) -> <HCons<H, Tail> as IntoReverse>::Output

Reverses a given data structure.

impl<T1, T2> IntoTuple2 for HCons<T1, HCons<T2, HNil>>

type HeadType = T1

The 0 element in the output tuple

type TailOutput = T2

The 1 element in the output tuple

pub fn into_tuple2(
    self
) -> (<HCons<T1, HCons<T2, HNil>> as IntoTuple2>::HeadType, <HCons<T1, HCons<T2, HNil>> as IntoTuple2>::TailOutput)

Turns an HList into nested Tuple2s, which are less troublesome to pattern match and have a nicer type signature.

impl<T, Tail> IntoTuple2 for HCons<T, Tail> where
    Tail: IntoTuple2, 

type HeadType = T

The 0 element in the output tuple

type TailOutput = (<Tail as IntoTuple2>::HeadType, <Tail as IntoTuple2>::TailOutput)

The 1 element in the output tuple

pub fn into_tuple2(
    self
) -> (<HCons<T, Tail> as IntoTuple2>::HeadType, <HCons<T, Tail> as IntoTuple2>::TailOutput)

Turns an HList into nested Tuple2s, which are less troublesome to pattern match and have a nicer type signature.

impl<Label, Value, Tail> IntoUnlabelled for HCons<Field<Label, Value>, Tail> where
    Tail: IntoUnlabelled, 

Implementation when we have a non-empty HCons holding a label in its head

type Output = HCons<Value, <Tail as IntoUnlabelled>::Output>

pub fn into_unlabelled(
    self
) -> <HCons<Field<Label, Value>, Tail> as IntoUnlabelled>::Output

Turns the current HList into an unlabelled one.

impl<Label, Value, Tail> IntoValueLabelled for HCons<Field<Label, Value>, Tail> where
    Tail: IntoValueLabelled, 

type Output = HCons<ValueField<Value>, <Tail as IntoValueLabelled>::Output>

pub fn into_value_labelled(
    self
) -> <HCons<Field<Label, Value>, Tail> as IntoValueLabelled>::Output

Turns the current HList into a value-labelled one.

impl<T, Tail> LiftFrom<T, Here> for HCons<T, Tail> where
    Tail: Default + HList, 

pub fn lift_from(part: T) -> HCons<T, Tail>

Performs the indexed conversion.

impl<Head, Tail, ValAtIx, TailIx> LiftFrom<ValAtIx, There<TailIx>> for HCons<Head, Tail> where
    Tail: HList + LiftFrom<ValAtIx, TailIx>,
    Head: Default, 

pub fn lift_from(part: ValAtIx) -> HCons<Head, Tail>

Performs the indexed conversion.

impl<H, T> Ord for HCons<H, T> where
    T: Ord,
    H: Ord, 

pub fn cmp(&self, other: &HCons<H, T>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<H, T> PartialEq<HCons<H, T>> for HCons<H, T> where
    T: PartialEq<T>,
    H: PartialEq<H>, 

pub fn eq(&self, other: &HCons<H, T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &HCons<H, T>) -> bool

This method tests for !=.

impl<H, T> PartialOrd<HCons<H, T>> for HCons<H, T> where
    T: PartialOrd<T>,
    H: PartialOrd<H>, 

pub fn partial_cmp(&self, other: &HCons<H, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<HeadName, TailNames, HeadPluckIndex, TailPluckIndices, Traversable> PathTraverser<Path<HCons<HeadName, Path<TailNames>>>, HCons<HeadPluckIndex, TailPluckIndices>> for Traversable where
    Traversable: IntoLabelledGeneric,
    <Traversable as IntoLabelledGeneric>::Repr: ByNameFieldPlucker<HeadName, HeadPluckIndex>,
    <<Traversable as IntoLabelledGeneric>::Repr as ByNameFieldPlucker<HeadName, HeadPluckIndex>>::TargetValue: PathTraverser<Path<TailNames>, TailPluckIndices>, 

type TargetValue = <<<Traversable as IntoLabelledGeneric>::Repr as ByNameFieldPlucker<HeadName, HeadPluckIndex>>::TargetValue as PathTraverser<Path<TailNames>, TailPluckIndices>>::TargetValue

pub fn get(
    self
) -> <Traversable as PathTraverser<Path<HCons<HeadName, Path<TailNames>>>, HCons<HeadPluckIndex, TailPluckIndices>>>::TargetValue

Returns a pair consisting of the value pointed to by the target key and the remainder.

impl<Head, Tail, FromTail, TailIndex> Plucker<FromTail, There<TailIndex>> for HCons<Head, Tail> where
    Tail: Plucker<FromTail, TailIndex>, 

Implementation when the pluck target is in the tail

type Remainder = HCons<Head, <Tail as Plucker<FromTail, TailIndex>>::Remainder>

What is left after you pluck the target from the Self

pub fn pluck(
    self
) -> (FromTail, <HCons<Head, Tail> as Plucker<FromTail, There<TailIndex>>>::Remainder)

Remove an element by type from an HList.

impl<T, Tail> Plucker<T, Here> for HCons<T, Tail>

Implementation when the pluck target is in head

type Remainder = Tail

What is left after you pluck the target from the Self

pub fn pluck(self) -> (T, <HCons<T, Tail> as Plucker<T, Here>>::Remainder)

Remove an element by type from an HList.

impl<THead, TTail, SHead, STail, IndexHead, IndexTail> Sculptor<HCons<THead, TTail>, HCons<IndexHead, IndexTail>> for HCons<SHead, STail> where
    HCons<SHead, STail>: Plucker<THead, IndexHead>,
    <HCons<SHead, STail> as Plucker<THead, IndexHead>>::Remainder: Sculptor<TTail, IndexTail>, 

Implementation for when we have a non-empty HCons target

Indices is HCons<IndexHead, IndexTail> here because the compiler is being asked to figure out the Index for Plucking the first item of type THead out of Self and the rest (IndexTail) is for the Plucker’s remainder induce.

type Remainder = <<HCons<SHead, STail> as Plucker<THead, IndexHead>>::Remainder as Sculptor<TTail, IndexTail>>::Remainder

pub fn sculpt(
    self
) -> (HCons<THead, TTail>, <HCons<SHead, STail> as Sculptor<HCons<THead, TTail>, HCons<IndexHead, IndexTail>>>::Remainder)

Consumes the current HList and returns an HList with the requested shape.

impl<Head, Tail, FromTail, TailIndex> Selector<FromTail, There<TailIndex>> for HCons<Head, Tail> where
    Tail: Selector<FromTail, TailIndex>, 

pub fn get(&self) -> &FromTail

Borrow an element by type from an HList.

pub fn get_mut(&mut self) -> &mut FromTail

Mutably borrow an element by type from an HList.

impl<T, Tail> Selector<T, Here> for HCons<T, Tail>

pub fn get(&self) -> &T

Borrow an element by type from an HList.

pub fn get_mut(&mut self) -> &mut T

Mutably borrow an element by type from an HList.

impl<H: Semigroup, T: HList + Semigroup> Semigroup for HCons<H, T>

Allow the combination of any two HLists having the same structure if all of the sub-element types are also Semiups

fn combine(&self, other: &Self) -> Self

Associative operation taking which combines two values.

impl<H, T> StructuralEq for HCons<H, T>

impl<H, T> StructuralPartialEq for HCons<H, T>

impl<'a, H, Tail> ToMut<'a> for HCons<H, Tail> where
    H: 'a,
    Tail: ToMut<'a>, 

type Output = HCons<&'a mut H, <Tail as ToMut<'a>>::Output>

pub fn to_mut(&'a mut self) -> <HCons<H, Tail> as ToMut<'a>>::Output

impl<'a, H, Tail> ToRef<'a> for HCons<H, Tail> where
    H: 'a,
    Tail: ToRef<'a>, 

type Output = HCons<&'a H, <Tail as ToRef<'a>>::Output>

pub fn to_ref(&'a self) -> <HCons<H, Tail> as ToRef<'a>>::Output

impl<SourceHead, SourceTail, TargetHeadName, TargetHeadValue, TargetTail, PluckSourceHeadNameIndex, TransMogSourceHeadValueIndices, TransMogTailIndices> Transmogrifier<HCons<Field<TargetHeadName, TargetHeadValue>, TargetTail>, HCons<DoTransmog<PluckSourceHeadNameIndex, TransMogSourceHeadValueIndices>, TransMogTailIndices>> for HCons<SourceHead, SourceTail> where
    HCons<SourceHead, SourceTail>: ByNameFieldPlucker<TargetHeadName, PluckSourceHeadNameIndex>,
    Field<TargetHeadName, <HCons<SourceHead, SourceTail> as ByNameFieldPlucker<TargetHeadName, PluckSourceHeadNameIndex>>::TargetValue>: Transmogrifier<TargetHeadValue, TransMogSourceHeadValueIndices>,
    <HCons<SourceHead, SourceTail> as ByNameFieldPlucker<TargetHeadName, PluckSourceHeadNameIndex>>::Remainder: Transmogrifier<TargetTail, TransMogTailIndices>, 

Non-trivial implementation of Transmogrifier where similarly-shaped Source and Target types are both Labelled HLists, but do not immediately transform into one another due to mis-matched fields, possibly recursively so.

pub fn transmogrify(
    self
) -> HCons<Field<TargetHeadName, TargetHeadValue>, TargetTail>

Consume this current object and return an object of the Target type.

impl<SourceHead, SourceTail, TargetName, TargetHead, TargetTail, TransmogHeadIndex, TransmogTailIndices> Transmogrifier<HCons<TargetHead, TargetTail>, HCons<TransmogHeadIndex, TransmogTailIndices>> for Field<TargetName, HCons<SourceHead, SourceTail>> where
    HCons<SourceHead, SourceTail>: Transmogrifier<HCons<TargetHead, TargetTail>, HCons<TransmogHeadIndex, TransmogTailIndices>>, 

Implementation of Transmogrifier for when the target is an HList, and the Source is a plucked HList.

pub fn transmogrify(self) -> HCons<TargetHead, TargetTail>

Consume this current object and return an object of the Target type.

impl<SourceHead, SourceTail> Transmogrifier<HNil, HNil> for HCons<SourceHead, SourceTail>

Implementation of Transmogrifier for when the Target is empty and the Source is non-empty.

pub fn transmogrify(self) -> HNil

Consume this current object and return an object of the Target type.