Trait frunk_core::generic::Generic

pub trait Generic {
    type Repr;
    fn into(self) -> Self::Repr;
    fn from(repr: Self::Repr) -> Self;

    fn convert_from<Src>(src: Src) -> Self
    where
        Self: Sized,
        Src: Generic<Repr = Self::Repr>,
    { ... }
    fn map_repr<Mapper>(self, mapper: Mapper) -> Self
    where
        Self: Sized,
        Mapper: FnOnce(Self::Repr) -> Self::Repr,
    { ... }
    fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self
    where
        Self: Sized,
        Inter: Generic<Repr = Self::Repr>,
        Mapper: FnOnce(Inter) -> Inter,
    { ... }
}

A trait that converts from a type to a generic representation.

For the most part, you should be using the derivation that is available through frunk_derive to generate instances of this trait for your types.

Laws

Any implementation of Generic must satisfy the following two laws:

1. forall x : Self. x == Generic::from(Generic::into(x))
2. forall y : Repr. y == Generic::into(Generic::from(y))

That is, from and into should make up an isomorphism between Self and the representation type Repr.

Examples

#[macro_use] extern crate frunk;
#[macro_use] extern crate frunk_core;

#[derive(Generic)]
struct ApiPerson<'a> {
    FirstName: &'a str,
    LastName: &'a str,
    Age: usize,
}

#[derive(Generic)]
struct DomainPerson<'a> {
    first_name: &'a str,
    last_name: &'a str,
    age: usize,
}

let a_person = ApiPerson {
    FirstName: "Joe",
    LastName: "Blow",
    Age: 30,
};
let d_person: DomainPerson = frunk::convert_from(a_person); // done

Associated Types

type Repr

The generic representation type.

Required Methods

fn into(self) -> Self::Repr

Convert a value to its representation type Repr.

fn from(repr: Self::Repr) -> Self

Convert a value's representation type Repr to the value's type.

Provided Methods

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

Convert a value to another type provided that they have the same representation type.

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

Maps the given value of type Self by first transforming it to the representation type Repr, then applying a mapper function on Repr and finally transforming it back to a value of type Self.

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

Maps the given value of type Self by first transforming it a type Inter that has the same representation type as Self, then applying a mapper function on Inter and finally transforming it back to a value of type Self.

Implementations on Foreign Types

impl Generic for ()

type Repr = HNil

fn into(self) -> Self::Repr

fn from(_: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

impl<T0> Generic for (T0,)

type Repr = HCons<T0, HNil>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

impl<T1, T0> Generic for (T1, T0)

type Repr = HCons<T1, HCons<T0, HNil>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

impl<T2, T1, T0> Generic for (T2, T1, T0)

type Repr = HCons<T2, HCons<T1, HCons<T0, HNil>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

impl<T3, T2, T1, T0> Generic for (T3, T2, T1, T0)

type Repr = HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

impl<T4, T3, T2, T1, T0> Generic for (T4, T3, T2, T1, T0)

type Repr = HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

impl<T5, T4, T3, T2, T1, T0> Generic for (T5, T4, T3, T2, T1, T0)

type Repr = HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

impl<T6, T5, T4, T3, T2, T1, T0> Generic for (T6, T5, T4, T3, T2, T1, T0)

type Repr = HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

impl<T7, T6, T5, T4, T3, T2, T1, T0> Generic for (T7, T6, T5, T4, T3, T2, T1, T0)

type Repr = HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T22, HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

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

type Repr = HCons<T23, HCons<T22, HCons<T21, HCons<T20, HCons<T19, HCons<T18, HCons<T17, HCons<T16, HCons<T15, HCons<T14, HCons<T13, HCons<T12, HCons<T11, HCons<T10, HCons<T9, HCons<T8, HCons<T7, HCons<T6, HCons<T5, HCons<T4, HCons<T3, HCons<T2, HCons<T1, HCons<T0, HNil>>>>>>>>>>>>>>>>>>>>>>>>

fn into(self) -> Self::Repr

fn from(r: Self::Repr) -> Self

fn convert_from<Src>(src: Src) -> Self where
    Self: Sized,
    Src: Generic<Repr = Self::Repr>, 

fn map_repr<Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Mapper: FnOnce(Self::Repr) -> Self::Repr, 

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self where
    Self: Sized,
    Inter: Generic<Repr = Self::Repr>,
    Mapper: FnOnce(Inter) -> Inter, 

Implementors