Enum Type 

pub enum Type {
    Any,
    Unit,
    Int,
    Float,
    String,
    Bool,
    None,
    Decimal,
    List(Box<Type>),
    Map(Box<Type>),
    Set(Box<Type>),
    Option(Box<Type>),
    Result(Box<Type>, Box<Type>),
    Function {
        params: Vec<Type>,
        ret: Box<Type>,
    },
    Struct(String),
    Enum(String),
    Table {
        name: Option<String>,
        columns: Option<Vec<(String, Type)>>,
    },
    Generator(Box<Type>),
    Task(Box<Type>),
    Channel(Box<Type>),
    Tensor,
    Stream(Box<Type>),
    Pipeline,
    TypeParam(String),
    Var(u32),
    PyObject,
    Ref(Box<Type>),
    Error,
}

Internal type representation used by the type checker. Separate from TypeExpr (AST surface syntax).

Variants

Any

Gradual typing: compatible with everything

Unit

Void return type

Int

Primitive types

Float

String

Bool

None

Decimal

Fixed-point decimal for financial data

List(Box<Type>)

Composite types

Map(Box<Type>)

Set(Box<Type>)

Option(Box<Type>)

Option: T or None

Result(Box<Type>, Box<Type>)

Result: Ok(T) or Err(E)

Function

Function type

Fields

params: Vec<Type>

ret: Box<Type>

Struct(String)

Named struct type

Enum(String)

Named enum type

Table

Table with optional schema name and typed columns

Fields

name: Option<String>

columns: Option<Vec<(String, Type)>>

Generator(Box<Type>)

Generator yielding T

Task(Box<Type>)

Task returning T

Channel(Box<Type>)

Channel carrying T

Tensor

Tensor type (shape is runtime-only)

Stream(Box<Type>)

Typed stream carrying elements of type T

Pipeline

Opaque pipeline type

TypeParam(String)

Type parameter (generic): T, U, etc.

Var(u32)

Inference variable (unresolved)

PyObject

An opaque Python object

Ref(Box<Type>)

Read-only reference type

Error

Poison type — suppresses further errors

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 Display for Type

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

Formats the value using the given formatter.

impl PartialEq for Type

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