Struct SumType 

pub struct SumType {
    pub variants: Box<[SumTypeVariant]>,
}

A structural sum type.

Unlike most languages, sums in SATS are structural and not nominal. When checking whether two nominal types are the same, their names and/or declaration sites (e.g., module / namespace) are considered. Meanwhile, a structural type system would only check the structure of the type itself, e.g., the names of its variants and their inner data types in the case of a sum.

This is also known as a discriminated union (implementation) or disjoint union. Another name is coproduct (category theory).

These structures are known as sum types because the number of possible values a sum

{ N_0(T_0), N_1(T_1), ..., N_n(T_n) }

is:

Σ (i ∈ 0..n). values(T_i)

so for example, values({ A(U64), B(Bool) }) = values(U64) + values(Bool).

See also:

• https://en.wikipedia.org/wiki/Tagged_union
• https://ncatlab.org/nlab/show/sum+type

Fields

variants: Box<[SumTypeVariant]>

The possible variants of the sum type.

The order is relevant as it defines the tags of the variants at runtime.

Implementations

impl SumType

pub fn decode<'a>( bytes: &mut impl BufReader<'a>, ) -> Result<SumType, DecodeError>

pub fn encode(&self, bytes: &mut impl BufWriter)

impl SumType

pub const fn new(variants: Box<[SumTypeVariant]>) -> SumType

Returns a sum type with these possible variants.

pub fn new_unnamed(types: Box<[AlgebraicType]>) -> SumType

Returns a sum type of unnamed variants taken from types.

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

Check whether this sum type is a structural option type.

A structural option type has some(T) as its first variant and none as its second. That is, { some(T), none } or some: T | none depending on your notation. Note that some and none are lowercase, unlike Rust’s Option. Order matters, and an option type with these variants in the opposite order will not be recognized.

If the type does look like a structural option type, returns the type T.

pub fn as_option_mut(&mut self) -> Option<&mut AlgebraicType>

Check whether this sum type is a structural option type.

A structural option type has some(T) as its first variant and none as its second. That is, { some(T), none } or some: T | none depending on your notation. Note that some and none are lowercase, unlike Rust’s Option. Order matters, and an option type with these variants in the opposite order will not be recognized.

If the type does look like a structural option type, returns the type T.

pub fn is_option(&self) -> bool

Check whether this sum type is a structural option type.

A structural option type has some(T) as its first variant and none as its second. That is, { some(T), none } or some: T | none depending on your notation. Note that some and none are lowercase, unlike Rust’s Option. Order matters, and an option type with these variants in the opposite order will not be recognized.

pub fn is_empty(&self) -> bool

Return whether this sum type is empty, that is, has no variants.

pub fn is_schedule_at(&self) -> bool

Return whether this sum type is the special ScheduleAt type, Interval(u64) | Time(u64). Does not follow Refs.

pub fn is_special(&self) -> bool

Returns whether this sum type is a special known type, currently Option or ScheduleAt.

pub fn is_simple_enum(&self) -> bool

Returns whether this sum type is like on in C without data attached to the variants.

pub fn get_variant(&self, tag_name: &str) -> Option<(u8, &SumTypeVariant)>

Returns the sum type variant using tag_name with their tag position.

pub fn get_variant_simple( &self, tag_name: &str, ) -> Option<(u8, &SumTypeVariant)>

Returns the sum type variant using tag_name with their tag position, if this is a Self::is_simple_enum

pub fn get_variant_by_tag(&self, tag: u8) -> Option<&SumTypeVariant>

Returns the sum type variant with the given tag.

pub fn type_check(&self, sv: &SumValue, typespace: &Typespace) -> bool

impl SumType

pub fn as_value(&self) -> AlgebraicValue

pub fn from_value( value: &AlgebraicValue, ) -> Result<SumType, ValueDeserializeError>

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<(), Error>

Formats the value using the given formatter.

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

fn deserialize<D>( deserializer: D, ) -> Result<SumType, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given deserializer.

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

fn deserialize<D>( deserializer: D, ) -> Result<SumType, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> From<[(&str, AlgebraicType); N]> for SumType

fn from(fields: [(&str, AlgebraicType); N]) -> SumType

Converts to this type from the input type.

impl<const N: usize> From<[(Option<&str>, AlgebraicType); N]> for SumType

fn from(fields: [(Option<&str>, AlgebraicType); N]) -> SumType

Converts to this type from the input type.

impl<const N: usize> From<[AlgebraicType; N]> for SumType

fn from(fields: [AlgebraicType; N]) -> SumType

Converts to this type from the input type.

impl<const N: usize> From<[SumTypeVariant; N]> for SumType

fn from(fields: [SumTypeVariant; N]) -> SumType

Converts to this type from the input type.

impl From<Box<[SumTypeVariant]>> for SumType

fn from(fields: Box<[SumTypeVariant]>) -> SumType

Converts to this type from the input type.

impl From<SumType> for AlgebraicType

fn from(original: SumType) -> AlgebraicType

Converts to this type from the input type.

impl Hash for SumType

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

where __H: Hasher,

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 MetaType for SumType

fn meta_type() -> AlgebraicType

Returns the type structure of this type as an AlgebraicType.

impl Ord for SumType

fn cmp(&self, other: &SumType) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for SumType

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

fn partial_cmp(&self, other: &SumType) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for SumType

fn serialize<S>( &self, __serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize self in the data format of S using the provided serializer.

impl Serialize for SumType

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl SpacetimeType for SumType

fn make_type<S>(__typespace: &mut S) -> AlgebraicType

where S: TypespaceBuilder,

Returns an AlgebraicType representing the type for Self in SATS and in the typing context in typespace. This is used by the automatic type registration system in Rust modules.

impl Eq for SumType

impl StructuralPartialEq for SumType