Enum Ty 

pub enum Ty {
    Base(BaseType),
    Named {
        name: String,
        kind: NamedKind,
    },
    Result(Box<Ty>, Box<Ty>),
    Option(Box<Ty>),
    Effect(Box<Ty>),
    HttpResult(Box<Ty>),
    QueueResult,
    List(Box<Ty>),
    Map(Box<Ty>, Box<Ty>),
    Query(Box<Ty>),
    Stream(Box<Ty>),
    Connection(Box<Ty>),
    ValidationError,
    JsonError,
    Unit,
    Actor(Box<Ty>),
    ActorSum(Vec<(String, Ty)>),
    Fn {
        params: Vec<Ty>,
        ret: Box<Ty>,
    },
    Var(String),
}

A resolved type.

Variants

Base(BaseType)

A base type (Int, String, Bool).

Named

A user-declared named type. kind records the declaration’s shape for compatibility / dispatch decisions.

Fields

name: String

kind: NamedKind

Result(Box<Ty>, Box<Ty>)

Result[T, E].

Option(Box<Ty>)

Option[T].

Effect(Box<Ty>)

Effect[T] (v0.5).

HttpResult(Box<Ty>)

HttpResult[T] (v0.9).

QueueResult

QueueResult — the built-in queue verdict sum (v0.44). Non-generic.

List(Box<Ty>)

List[T] — built-in immutable list (v0.20b).

Map(Box<Ty>, Box<Ty>)

Map[K, V] — built-in immutable map (v0.20b). The key type is confined to value-keyable types at TypeRef resolution.

Query(Box<Ty>)

Query[T] — a lazy, by-reference description of a read over agent-local storage (v0.91, ADR 0115). The inner type is the element a terminal yields. Built by the lazy combinator vocabulary over a store field, executed by a terminal (-> Effect[…]). Non-storable, non-boundary, and not value-comparable — like Effect/Fn (ADRs 0031/0030).

Stream(Box<Ty>)

Stream[T] — a lazy, pull-shaped sequence of values produced over time (v0.100, real-time track slice 0). The inner type is the element a terminal yields. Built from a runtime source (Stream.of at v1), transformed by lazy builders (map/take), drained by a terminal (collect -> Effect[List[T]]). Non-storable, non-boundary, and not value-comparable — like Query/Effect/Fn (ADRs 0031/0030).

Connection(Box<Ty>)

Connection[F] — a held WebSocket connection (v0.102, real-time track slice 2). F is the server→client frame type. The one concrete instance of the closed Held kind (is_held). Governed by the linearity discipline (§2.9): single-owner, mandatory disposal. Non-serialisable, non-boundary, non-comparable; storable only in Cell[Option[Connection]] / Map[K, Connection].

ValidationError

ValidationError — built-in error type.

JsonError

JsonError — built-in JSON-decode error type (v0.22b). A uniform record: kind/path/message, all String.

Unit

() — the unit type (v0.5).

Actor(Box<Ty>)

v0.45: a verified actor binding (by name: Actor). The inner type is the actor’s identity, read as name.identity. A boundary-minted, sealed value — only ever .identity-accessed, never constructed or passed.

ActorSum(Vec<(String, Ty)>)

v0.52: a resolved multi-actor binding (by who: A | B) — an ordered sum of peer actors. Each member is (actor name, identity ty); the body matches on the resolved actor, each non-unit member binding its identity directly. Like Actor, a sealed boundary value — only ever matched, never constructed or passed.

Fn

A -> B — a function type (v0.20a). Effectful iff ret is Effect[_] (the structural rule); no separate flag, so there is a single source of truth.

Fields

params: Vec<Ty>

ret: Box<Ty>

Var(String)

A function type parameter (v0.20a). Two lives: rigid while checking a generic function’s own body (name-equality in compatible), and flexible during call-site instantiation, where it is matched by unify and fully eliminated by substitute before any compatible runs against argument types. Vars never escape call checking into the caller’s expression types.

Implementations

impl Ty

pub fn display(&self) -> String

Display name for diagnostics.

pub fn is_effect(&self) -> bool

True if this type is Effect[_].

pub fn is_held(&self) -> bool

v0.102: true if this type belongs to the closed Held kind — a runtime-managed resource governed by the linearity discipline (§2.9). The one instance at v1 is Connection[F]; the single extension point for future held types (file handles, DB connections).

pub fn held_inner(&self) -> Option<&Ty>

v0.102: for a Held type, the held element it wraps (the frame type of a Connection[F]). Used by the storage-admission rules to look through an Option[Connection] value.

pub fn base(&self) -> Option<BaseType>

The underlying base type, if this type widens to a base type. Opaque types deliberately do NOT widen — that’s the whole point of the opacity — so Ty::Named { kind: Opaque(_), .. } returns None.

Trait Implementations

impl Clone for Ty

fn clone(&self) -> Ty

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ty

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

Formats the value using the given formatter.

impl PartialEq for Ty

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

impl StructuralPartialEq for Ty