Enum SemanticType 

pub enum SemanticType {
    Number,
    Integer,
    Bool,
    String,
    Option(Box<SemanticType>),
    Result {
        ok_type: Box<SemanticType>,
        err_type: Option<Box<SemanticType>>,
    },
    Array(Box<SemanticType>),
    Struct {
        name: String,
        fields: Vec<(String, SemanticType)>,
    },
    Enum {
        name: String,
        variants: Vec<EnumVariant>,
        type_params: Vec<String>,
    },
    Interface {
        name: String,
        methods: Vec<(String, FunctionSignature)>,
    },
    TypeVar(TypeVarId),
    Named(String),
    Generic {
        name: String,
        args: Vec<SemanticType>,
    },
    Ref(Box<SemanticType>),
    RefMut(Box<SemanticType>),
    Never,
    Void,
    Function(Box<FunctionSignature>),
}

Semantic types - what the user sees in type annotations

Variants

Number

Floating-point number (f64)

Integer

Integer (i64)

Bool

Boolean

String

String

Option(Box<SemanticType>)

Optional value: Option

• For numeric T: Uses NaN sentinel in storage
• For other T: Uses discriminated union

Result

Result type: Result or Result<T, E>

• err_type = None means universal Error type

Fields

ok_type: Box<SemanticType>

err_type: Option<Box<SemanticType>>

Array(Box<SemanticType>)

Array of values: Vec

Struct

Struct type with name and fields

Fields

name: String

fields: Vec<(String, SemanticType)>

Enum

Enum type with variants

Fields

name: String

variants: Vec<EnumVariant>

type_params: Vec<String>

Interface

Interface/trait type

Fields

name: String

methods: Vec<(String, FunctionSignature)>

TypeVar(TypeVarId)

Type variable for inference (α, β, γ)

Named(String)

Named type reference (before resolution)

Generic

Generic type instantiation: MyType<A, B>

Fields

name: String

args: Vec<SemanticType>

Ref(Box<SemanticType>)

Shared reference to a value: &T

RefMut(Box<SemanticType>)

Exclusive (mutable) reference to a value: &mut T

Never

Bottom type - computation that never returns (e.g., panic, infinite loop)

Void

Void - no value

Function(Box<FunctionSignature>)

Function type

Implementations

impl SemanticType

pub fn option(inner: SemanticType) -> Self

Create Option type

pub fn result(ok_type: SemanticType) -> Self

Create Result type with universal Error

pub fn result_with_error(ok_type: SemanticType, err_type: SemanticType) -> Self

Create Result<T, E> type with specific error

pub fn array(element: SemanticType) -> Self

Create Vec type

pub fn shared_ref(inner: SemanticType) -> Self

Create shared reference type: &T

pub fn exclusive_ref(inner: SemanticType) -> Self

Create exclusive reference type: &mut T

pub fn function(params: Vec<SemanticType>, return_type: SemanticType) -> Self

Create function type

pub fn is_numeric(&self) -> bool

Check if type is numeric (for propagating operators)

pub fn is_integer_family(&self) -> bool

Check if this semantic type is in the integer family.

pub fn is_number_family(&self) -> bool

Check if this semantic type is in the floating-point family.

pub fn is_reference(&self) -> bool

Check if this is a reference type (&T or &mut T).

pub fn is_exclusive_ref(&self) -> bool

Check if this is an exclusive (mutable) reference type (&mut T).

pub fn deref_type(&self) -> Option<&SemanticType>

Get the inner type of a reference (&T → T, &mut T → T).

pub fn auto_deref(&self) -> &SemanticType

Strip reference wrappers to get the underlying value type. For non-reference types, returns self.

pub fn is_option(&self) -> bool

Check if type is optional

pub fn is_result(&self) -> bool

Check if type is a result

pub fn option_inner(&self) -> Option<&SemanticType>

Get inner type of Option

pub fn result_ok_type(&self) -> Option<&SemanticType>

Get ok type of Result<T, E>

pub fn has_type_vars(&self) -> bool

Check if type contains unresolved type variables

pub fn to_type_info(&self) -> TypeInfo

Convert semantic type to wire protocol TypeInfo

This bridges the compile-time type system with the wire format used for REPL display and external tool integration.

impl SemanticType

pub fn to_inference_type(&self) -> Type

Convert SemanticType to inference Type

This allows using semantic types in the inference engine.

Trait Implementations

impl Clone for SemanticType

fn clone(&self) -> SemanticType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SemanticType

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

Formats the value using the given formatter.

impl Display for SemanticType

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

Formats the value using the given formatter.

impl Hash for SemanticType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SemanticType

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

impl StructuralPartialEq for SemanticType