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>,
    },
}

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)

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

Formats the value using the given formatter.