Enum SumType 

#[non_exhaustive]
pub enum SumType {
    Unit {
        size: u8,
    },
    General {
        rows: Vec<TypeRowRV>,
    },
}

Representation of a Sum type. Either store the types of the variants, or in the special (but common) case of a UnitSum (sum over empty tuples), store only the size of the Sum.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Unit

Special case of a Sum over unit types.

Fields

size: u8

General

General case of a Sum type.

Fields

rows: Vec<TypeRowRV>

Implementations

impl SumType

pub fn check_type(&self, tag: usize, val: &[Value]) -> Result<(), SumTypeError>

Check if a sum variant is a valid instance of this SumType.

Since Value::Sum variants always contain a tuple of values, val must be a slice of Values.

Errors

This function will return an error if there is a type check error.

impl SumType

pub fn new<V>(variants: impl IntoIterator<Item = V>) -> Self

where V: Into<TypeRowRV>,

Initialize a new sum type.

pub const fn new_unary(size: u8) -> Self

New UnitSum with empty Tuple variants.

pub fn new_tuple(types: impl Into<TypeRow>) -> Self

New tuple (single row of variants).

pub fn new_option(types: impl Into<TypeRow>) -> Self

New option type (either an empty option, or a row of types).

pub fn get_variant(&self, tag: usize) -> Option<&TypeRowRV>

Report the tag’th variant, if it exists.

pub fn num_variants(&self) -> usize

Returns the number of variants in the sum type.

pub fn as_tuple(&self) -> Option<&TypeRowRV>

Returns variant row if there is only one variant.

pub fn as_option(&self) -> Option<&TypeRowRV>

If the sum matches the convention of Option[row], return the row.

pub fn as_unary_option(&self) -> Option<&TypeRV>

If a sum is an option of a single type, return the type.

pub fn variants(&self) -> impl Iterator<Item = &TypeRowRV>

Returns an iterator over the variants.

Trait Implementations

impl Clone for SumType

fn clone(&self) -> SumType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SumType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SumType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SumType

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

Formats the value using the given formatter.

impl<RV: MaybeRV> From<SumType> for TypeBase<RV>

fn from(sum: SumType) -> Self

Converts to this type from the input type.

impl Hash for SumType

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SumType

fn eq(&self, other: &Self) -> 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 Serialize for SumType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Transformable for SumType

fn transform<T: TypeTransformer>(&mut self, tr: &T) -> Result<bool, T::Err>

Applies a TypeTransformer to this instance.

impl Eq for SumType