Enum TypeExpr 

pub enum TypeExpr<'a> {
    Primitive(Symbol),
    Named(Symbol),
    Generic {
        base: Symbol,
        params: &'a [TypeExpr<'a>],
    },
    Function {
        inputs: &'a [TypeExpr<'a>],
        output: &'a TypeExpr<'a>,
    },
    Refinement {
        base: &'a TypeExpr<'a>,
        var: Symbol,
        predicate: &'a LogicExpr<'a>,
    },
    Persistent {
        inner: &'a TypeExpr<'a>,
    },
    Mutable {
        inner: &'a TypeExpr<'a>,
    },
}

Type expression for explicit type annotations.

Represents type syntax like:

• Int → Primitive(Int)
• User → Named(User)
• List of Int → Generic { base: List, params: [Primitive(Int)] }
• List of List of Int → Generic { base: List, params: [Generic { base: List, params: [Primitive(Int)] }] }
• Result of Int and Text → Generic { base: Result, params: [Primitive(Int), Primitive(Text)] }

Variants

Primitive(Symbol)

Primitive type: Int, Nat, Text, Bool

Named(Symbol)

Named type (user-defined): User, Point

Generic

Generic type: List of Int, Option of Text, Result of Int and Text

Fields

base: Symbol

params: &'a [TypeExpr<'a>]

Function

Function type: fn(A, B) -> C (for higher-order functions)

Fields

inputs: &'a [TypeExpr<'a>]

output: &'a TypeExpr<'a>

Refinement

Refinement type with predicate constraint. Example: Int where it > 0

Fields

base: &'a TypeExpr<'a>

The base type being refined

var: Symbol

The bound variable (usually “it”)

predicate: &'a LogicExpr<'a>

The predicate constraint (from Logic Kernel)

Persistent

Persistent storage wrapper type. Example: Persistent Counter Semantics: Wraps a Shared type with journal-backed storage

Fields

inner: &'a TypeExpr<'a>

The inner type (must be a Shared/CRDT type)

Mutable

Mutable-parameter marker (Mutable Value Semantics escape hatch). Example: ## To addItem (items: mutable Seq of Int): → Mutable { inner: Generic { List, [Int] } }. Semantics: under value semantics collections pass by value by default; a Mutable parameter passes by reference so the callee’s mutations are visible to the caller (the explicit, opt-in form of the void-mutate idiom). Carried on the parameter’s type so the (Symbol, &TypeExpr) parameter representation is unchanged. For every purpose other than the parameter-passing convention, Mutable { inner } behaves as inner.

Fields

inner: &'a TypeExpr<'a>

The underlying parameter type.

Trait Implementations

impl<'a> Clone for TypeExpr<'a>

fn clone(&self) -> TypeExpr<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TypeExpr<'a>

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

Formats the value using the given formatter.