Struct Cons 

pub struct Cons<Head, Tail>(pub Head, pub Tail);

The Cons type, a.k.a. π, is used to represent the head of a type-level list, also known as an anonymous product type.

Cons is used together with Nil to produce a type-level list using the Product! macro.

Cons is also shown as π, together with Nil shown as ε, to improve the readability of compiler error messages. Through the shortened name, a product type would take slightly less space, making it more likely to fit on a single line for the user to read what the type is.

Example

Given the following product type definition:

type MyTypes = Product![u32, String, bool];

The following type would be generated:

type MyTypes = Cons<u32, Cons<String, Cons<bool, Nil>>>;

which would be shown with the shortened representation as:

type MyTypes = π<u32, π<String, π<bool, ε>>>;

Tuple Fields

0: Head

1: Tail

Trait Implementations

impl<Head, Tail> Clone for π<Head, Tail>

where Head: Clone, Tail: Clone,

fn clone(&self) -> π<Head, Tail>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Head, Tail> Debug for π<Head, Tail>

where Head: Debug, Tail: Debug,

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

Formats the value using the given formatter.

impl<Head, Tail> Default for π<Head, Tail>

where Head: Default, Tail: Default,

fn default() -> π<Head, Tail>

Returns the “default value” for a type.

impl<Mapper, Current, Rest> MapFields<Mapper> for π<Current, Rest>

where Mapper: MapType, Rest: MapFields<Mapper>,

type Mapped = π<<Mapper as MapType>::Map<Current>, <Rest as MapFields<Mapper>>::Mapped>

impl<Head, Tail> PartialEq for π<Head, Tail>

where Head: PartialEq, Tail: PartialEq,

fn eq(&self, other: &π<Head, Tail>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Head, Tail> Eq for π<Head, Tail>

where Head: Eq, Tail: Eq,

impl<Head, Tail> StructuralPartialEq for π<Head, Tail>