Trait IntoList 

pub trait IntoList {
    type Output<T: EmptyList>: List;

    // Required method
    fn into_list<T: EmptyList>(self) -> Self::Output<T>;
}

Convert into a type-level List, consuming self.

Required Associated Types

type Output<T: EmptyList>: List

The resulting List type using T as the empty list type family.

Required Methods

fn into_list<T: EmptyList>(self) -> Self::Output<T>

Convert into a List using T as the empty list type family.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl IntoList for ()

type Output<T: EmptyList> = <T as List>::Empty

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> IntoList for (A, B, C, D, E, F, G, H, I, J, K, L)

type Output<T: EmptyList> = <<(B, C, D, E, F, G, H, I, J, K, L) as IntoList>::Output<T> as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> IntoList for (A, B, C, D, E, F, G, H, I, J, K)

type Output<T: EmptyList> = <<(B, C, D, E, F, G, H, I, J, K) as IntoList>::Output<T> as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> IntoList for (A, B, C, D, E, F, G, H, I, J)

type Output<T: EmptyList> = <<(B, C, D, E, F, G, H, I, J) as IntoList>::Output<T> as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> IntoList for (A, B, C, D, E, F, G, H, I)

type Output<T: EmptyList> = <<(B, C, D, E, F, G, H, I) as IntoList>::Output<T> as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> IntoList for (A, B, C, D, E, F, G, H)

type Output<T: EmptyList> = <<(B, C, D, E, F, G, H) as IntoList>::Output<T> as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> IntoList for (A, B, C, D, E, F, G)

type Output<T: EmptyList> = <<(B, C, D, E, F, G) as IntoList>::Output<T> as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> IntoList for (A, B, C, D, E, F)

type Output<T: EmptyList> = <<(B, C, D, E, F) as IntoList>::Output<T> as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> IntoList for (A, B, C, D, E)

type Output<T: EmptyList> = <<(B, C, D, E) as IntoList>::Output<T> as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static, B: 'static, C: 'static, D: 'static> IntoList for (A, B, C, D)

type Output<T: EmptyList> = <<(B, C, D) as IntoList>::Output<T> as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static, B: 'static, C: 'static> IntoList for (A, B, C)

type Output<T: EmptyList> = <<(B, C) as IntoList>::Output<T> as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static, B: 'static> IntoList for (A, B)

type Output<T: EmptyList> = <<(B,) as IntoList>::Output<T> as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

impl<A: 'static> IntoList for (A,)

type Output<T: EmptyList> = <<T as List>::Empty as List>::Push<A>

fn into_list<T: EmptyList>(self) -> Self::Output<T>

Implementors