Enum Type 

pub enum Type {
    Int,
    Float,
    Bool,
    String,
    Bytes,
    Unit,
    List {
        elem: Box<Type>,
    },
    Tuple {
        elems: Vec<Type>,
    },
    Record {
        fields: Vec<RecordField>,
    },
    Sum {
        variants: Vec<Variant>,
    },
    Fun {
        params: Vec<Type>,
        ret: Box<Type>,
    },
    Var {
        name: String,
    },
}

Static type attached to a subtree via AlephTree::Typed, or to a TypeDef’s variant fields. Deliberately small: enough to type-check records, sum types, and function signatures (see the Aleph-Next spec) without committing yet to full parametric polymorphism.

Variants

Int

64-bit signed integer.

Float

64-bit floating point number.

Bool

Boolean.

String

UTF-8 text.

Bytes

Raw byte sequence.

Unit

The single-valued “nothing” type.

#[default] here exists only so AlephTree’s strum::EnumString derive can build a placeholder Type value for its FromStr path (which requires every struct-like variant’s fields to implement Default). It is not a sentinel for “no type annotation” — use Option<Type> for that. Don’t let Type::default() leak into real type-checking logic.

List

Homogeneous list of elem.

Fields

elem: Box<Type>

Tuple

Fixed-size heterogeneous tuple.

Fields

elems: Vec<Type>

Record

Named-field record (struct).

Fields

fields: Vec<RecordField>

Sum

Tagged union of named variants (sum/enum type).

Fields

variants: Vec<Variant>

Fun

Function signature: positional parameter types and a return type.

Fields

params: Vec<Type>

ret: Box<Type>

Var

A type variable, referenced by name (for as-yet-unresolved/generic types).

Fields

name: String

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl Default for Type

fn default() -> Type

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Type

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Type

impl PartialEq for Type

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Type

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Type