Struct spacetimedb_sats::sum_type::SumType

pub struct SumType {
    pub variants: Vec<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://ncatlab.org/nlab/show/sum+type.

Fields

variants: Vec<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<Self, DecodeError>

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

impl SumType

pub const fn new(variants: Vec<SumTypeVariant>) -> Self

Returns a sum type with these possible variants.

pub fn new_unnamed(types: Vec<AlgebraicType>) -> Self

Returns a sum type of unnamed variants taken from types.

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

Returns whether this sum type looks like an option type.

An 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.

pub fn is_simple_enum(&self) -> bool

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

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 copy 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<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given deserializer.

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

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

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]) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

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 From<Vec<SumTypeVariant>> for SumType

fn from(fields: Vec<SumTypeVariant>) -> 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 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for SumType

fn eq(&self, other: &SumType) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method 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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for SumType

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

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

impl Eq for SumType

impl StructuralPartialEq for SumType