Enum TypeExpr 

pub enum TypeExpr {
    Named {
        name: String,
        args: Vec<TypeExpr>,
    },
    Record(Vec<TypeField>),
    Tuple(Vec<TypeExpr>),
    Function {
        params: Vec<TypeExpr>,
        effects: Vec<Effect>,
        ret: Box<TypeExpr>,
    },
    Union(Vec<UnionVariant>),
    RecordWithSpreads {
        spreads: Vec<String>,
        fields: Vec<TypeField>,
    },
    Refined {
        base: Box<TypeExpr>,
        binding: String,
        predicate: Box<Expr>,
    },
}

Variants

Named

Named primitive or constructor application (Int, Result[Int, Str], T). We resolve which it is during type-checking, not parsing.

Fields

name: String

args: Vec<TypeExpr>

Record(Vec<TypeField>)

Tuple(Vec<TypeExpr>)

Function

Fields

params: Vec<TypeExpr>

effects: Vec<Effect>

ret: Box<TypeExpr>

Union(Vec<UnionVariant>)

RecordWithSpreads

Record type with one or more spread bases (#363): { ...TypeName, field :: Type }. Resolved to a flat Ty::Record during type-checking.

Fields

spreads: Vec<String>

fields: Vec<TypeField>

Refined

Refinement type (#209): a base type plus a predicate the inhabitant must satisfy. Int{x | x > 0 and x <= balance} parses with base = Named { name: "Int", args: [] }, binding = "x", and predicate = (x > 0) and (x <= balance). Slice 1 stores the refinement; the type checker treats the refined type as its base. Slice 2 wires up static discharge via the spec-checker’s gate evaluator; slice 3 adds the residual runtime check at call boundaries.

Fields

base: Box<TypeExpr>

binding: String

predicate: Box<Expr>

Trait Implementations

impl Clone for TypeExpr

fn clone(&self) -> TypeExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TypeExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TypeExpr

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

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 TypeExpr