Struct frunk::hlist::HCons

source ·
pub struct HCons<H, T> {
    pub head: H,
    pub tail: T,
}
Expand description

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§

source§

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

source

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
use frunk_core::hlist;

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

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

source

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

Returns the length of a given HList

Examples
use frunk_core::hlist;

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

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

Returns whether a given HList is empty

Examples
use frunk_core::hlist;

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

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
use frunk_core::hlist;

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");
Run
source

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/sculpt 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
use frunk_core::{hlist, HList};

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]);
Run
source

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

Reverse the HList.

Examples
use frunk_core::hlist;

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

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

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
use frunk_core::hlist;

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

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

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
use frunk_core::hlist;

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

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

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;
use frunk_core::hlist;

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]);
Run
source

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;
use frunk_core::hlist;

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),
]);
Run
source

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
Run
Examples
use frunk_core::hlist;

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)
Run
source

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
use frunk_core::hlist;

let nil = hlist![];

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

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

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

assert_eq!(9001, folded)
Run
source

pub fn extend<Other>( self, other: Other ) -> <HCons<Head, Tail> as Add<Other>>::Output
where HCons<Head, Tail>: Add<Other>, Other: HList,

Extend the contents of this HList with another HList

This exactly the same as the Add impl.

Examples
use frunk_core::hlist;

let first = hlist![0u8, 1u16];
let second = hlist![2u32, 3u64];

assert_eq!(first.extend(second), hlist![0u8, 1u16, 2u32, 3u64]);
Run
source§

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

source

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

Borrow an element by type from an HList.

Examples
use frunk_core::hlist;

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!!"),
}
Run
source

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
use frunk_core::hlist;

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]);
Run
source

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
use frunk_core::hlist;

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])
Run
source

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
use frunk_core::hlist;

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);
Run

Trait Implementations§

source§

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.
source§

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

Performs the + operation. Read more
source§

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

source§

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.
source§

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>

source§

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.
source§

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

source§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

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

source§

fn embed(self) -> Out

Convert a coproduct into another that can hold its variants. Read more
source§

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

source§

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

Use functions to fold a coproduct into a single value. Read more
source§

impl<'a, F, R, MapperTail, CH, CTail> CoproductMappable<&'a HCons<F, MapperTail>> for Coproduct<CH, CTail>
where F: Fn(CH) -> R, CTail: CoproductMappable<&'a MapperTail>,

Implementation for mapping a Coproduct using a &hlist!.

§

type Output = Coproduct<R, <CTail as CoproductMappable<&'a MapperTail>>::Output>

source§

fn map( self, mapper: &'a HCons<F, MapperTail> ) -> <Coproduct<CH, CTail> as CoproductMappable<&'a HCons<F, MapperTail>>>::Output

Use functions to map each variant of a coproduct. Read more
source§

impl<'a, F, R, MapperTail, CH, CTail> CoproductMappable<&'a mut HCons<F, MapperTail>> for Coproduct<CH, CTail>
where F: FnMut(CH) -> R, CTail: CoproductMappable<&'a mut MapperTail>,

Implementation for mapping a Coproduct using a &mut hlist!.

§

type Output = Coproduct<R, <CTail as CoproductMappable<&'a mut MapperTail>>::Output>

source§

fn map( self, mapper: &'a mut HCons<F, MapperTail> ) -> <Coproduct<CH, CTail> as CoproductMappable<&'a mut HCons<F, MapperTail>>>::Output

Use functions to map each variant of a coproduct. Read more
source§

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

Implementation for mapping a Coproduct using an hlist!.

§

type Output = Coproduct<R, <CTail as CoproductMappable<MapperTail>>::Output>

source§

fn map( self, mapper: HCons<F, MapperTail> ) -> <Coproduct<CH, CTail> as CoproductMappable<HCons<F, MapperTail>>>::Output

Use functions to map each variant of a coproduct. Read more
source§

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

source§

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

Formats the value using the given formatter. Read more
source§

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

source§

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

Returns the “default value” for a type. Read more
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, T3: From<F3>, T4: From<F4>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, T3: From<F3>, T4: From<F4>, T5: From<F5>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, T3: From<F3>, T4: From<F4>, T5: From<F5>, T6: From<F6>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, T3: From<F3>, T4: From<F4>, T5: From<F5>, T6: From<F6>, T7: From<F7>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, T3: From<F3>, T4: From<F4>, T5: From<F5>, T6: From<F6>, T7: From<F7>, T8: From<F8>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, T3: From<F3>, T4: From<F4>, T5: From<F5>, T6: From<F6>, T7: From<F7>, T8: From<F8>, T9: From<F9>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, T3: From<F3>, T4: From<F4>, T5: From<F5>, T6: From<F6>, T7: From<F7>, T8: From<F8>, T9: From<F9>, T10: From<F10>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: From<F1>, T2: From<F2>, 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: Default, T3: Default, T4: Default, T5: Default, T6: Default, T7: Default, T8: Default, T9: Default, T10: From<F10>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: Default, T3: Default, T4: Default, T5: Default, T6: Default, T7: Default, T8: Default, T9: Default, T10: From<F10>, T11: From<F11>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: Default, T3: Default, T4: Default, T5: Default, T6: Default, T7: Default, T8: Default, T9: Default, T10: From<F10>, T11: From<F11>, T12: From<F12>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: Default, T3: Default, T4: Default, T5: Default, T6: Default, T7: Default, T8: Default, T9: Default, T10: Default, T11: From<F11>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: Default, T3: Default, T4: Default, T5: Default, T6: Default, T7: Default, T8: Default, T9: Default, T10: Default, T11: From<F11>, T12: From<F12>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: Default, T3: Default, T4: Default, T5: Default, T6: Default, T7: Default, T8: Default, T9: Default, T10: Default, T11: Default, T12: From<F12>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: Default, T3: Default, T4: Default, T5: Default, T6: Default, T7: Default, T8: Default, T9: Default, T10: Default, T11: Default, T12: Default, T13: From<F13>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

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

Converts to this type from the input type.
source§

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 T0: Default, T1: Default, T2: 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>,

source§

fn from( f: (F17, F18) ) -> HCons<T0, HCons<T1, HCons<T2, HCons<T3, HCons<T4,