Struct Field 

pub struct Field<Tag, Value> {
    pub value: Value,
    pub phantom: PhantomData<Tag>,
}

The Field type, a.k.a. ω, is used to represent a named field entry within a product type or a sum type.

Field is parameterized by a phantom Tag type, which is used to represent the field name as type. Typically, this would either be a type-level string such as Symbol!("name"), or a type-level index such as Index<0>. Aside from that, Field is essentially a wrapper around Value.

Field is mainly used within the derived HasFields implementations, to include the field name in the generic product or sum representation of the given struct or enum.

Field is also shown as ω to improve the readability of compiler error messages. It is mainly useful when the type from HasFields::Fields is shown, which would contain a lot of Fields and tend to take up a lot of screen space to read.

Example

Given the following struct definition:

#[derive(HasFields)]
pub struct MyContext {
    pub name: String,
    pub age: u8,
}

The following HasFields implementation would be generated:

impl HasFields for MyContext {
    type Fields = Product![Field<Symbol!("name"), String>, Field<Symbol!("age"), u8>];
}

which would be shown with the shortened representation as:

impl HasFields for MyContext {
    type Fields =
        π<ω<Symbol!("name"), String>,
            π<ω<Symbol!("age"), u8>,
                ε>>;
}

Fields

value: Value

phantom: PhantomData<Tag>

Trait Implementations

impl<Tag, Value> Debug for ω<Tag, Value>

where Value: Debug,

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

Formats the value using the given formatter.

impl<Tag, Value> From<Value> for ω<Tag, Value>

fn from(value: Value) -> ω<Tag, Value>

Converts to this type from the input type.

impl<Tag, Value> PartialEq for ω<Tag, Value>

where Value: PartialEq,

fn eq(&self, other: &ω<Tag, Value>) -> 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<Tag, Value> Eq for ω<Tag, Value>

where Value: Eq,