Enum Either 

pub enum Either<Head, Tail> {
    Left(Head),
    Right(Tail),
}

The Either type, a.k.a. σ, is used to represent an anonymous sum type.

Similar to Cons, Either is used to form a sum type by combining a chain of Either types, and terminated with a Void type. But unlike product types, a sum type has values that belong to one of the variants in the list.

Either is also shown as σ, together with Void shown as θ, to improve the readability of compiler error messages. Through the shortened name, a sum 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.

Either is most often used through the Sum! macro, which accepts a list of types and turns them into a chain of Either types.

Example

Given the following sum type definition:

type MyUnion = Sum![u32, String, bool];

The following type would be generated:

type MyUnion = Either<u32, Either<String, Either<bool, Void>>>;

which would be shown with the shortened representation as:

type MyUnion = σ<u32, σ<String, σ<bool, θ>>>;

Variants

Left(Head)

Right(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<Source, Target, Tag, Value, RestFields, Remainder> FieldsExtractor<Source, Target> for σ<ω<Tag, Value>, RestFields>

where Source: ExtractField<Tag, Value = Value>, Target: FromVariant<Tag, Value = Value>, RestFields: FieldsExtractor<<Source as ExtractField<Tag>>::Remainder, Target, Remainder = Remainder>,

type Remainder = Remainder

fn extract_from(source: Source) -> Result<Target, Remainder>

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>