Enum Type 

pub enum Type {
    Int,
    Float,
    Number,
    String,
    Bool,
    Symbol,
    None,
    Markdown,
    Array(Box<Type>),
    Tuple(Vec<Type>),
    Dict(Box<Type>, Box<Type>),
    Function(Vec<Type>, Box<Type>),
    Union(Vec<Type>),
    Record(BTreeMap<String, Type>, Box<Type>),
    RowEmpty,
    Var(TypeVarId),
    Never,
}

Represents a type in the mq type system

Variants

Int

Integer type

Float

Floating point type

Number

Number type (unified numeric type)

String

String type

Bool

Boolean type

Symbol

Symbol type

None

None/null type

Markdown

Markdown document type

Array(Box<Type>)

Array type with element type

Tuple(Vec<Type>)

Tuple type with known element types (e.g., (number, string))

Used when --tuple mode is enabled to track per-element types for small heterogeneous arrays like [1, "hello"].

Dict(Box<Type>, Box<Type>)

Dictionary type with key and value types

Function(Vec<Type>, Box<Type>)

Function type: arguments -> return type

Union(Vec<Type>)

Union type: represents a value that could be one of multiple types Used for try/catch expressions with different branch types

Record(BTreeMap<String, Type>, Box<Type>)

Record type with known fields and optional row extension (row polymorphism).

The first element is a map of field names to their types. The second element is the row tail: either RowEmpty (closed record) or Var(id) (open record that may have additional fields).

Examples:

• {a: number, b: string} → Record({"a": Number, "b": String}, RowEmpty)
• {a: number | r} → Record({"a": Number}, Var(r))

RowEmpty

Empty row — marks a closed record with no additional fields

Var(TypeVarId)

Type variable for inference

Never

Never type (bottom type) — represents unreachable code paths.

Produced when type narrowing eliminates all possible types from a union. For example, Union(Array(String), Array(Number)) minus is_array predicate leaves no viable types, producing Never for the else-branch.

Implementations

impl Type

pub fn function(params: Vec<Type>, ret: Type) -> Self

Creates a new function type

pub fn array(elem: Type) -> Self

Creates a new array type

pub fn tuple(elems: Vec<Type>) -> Self

Creates a new tuple type with known element types

pub fn dict(key: Type, value: Type) -> Self

Creates a new dict type

pub fn record(fields: BTreeMap<String, Type>, rest: Type) -> Self

Creates a new record type with known fields

pub fn union(types: Vec<Type>) -> Self

Creates a new union type from two or more types Automatically normalizes the union (removes duplicates, flattens nested unions)

pub fn subtract(&self, exclude: &Type) -> Type

Removes a type from a union by discriminant, returning the remaining type.

If this is not a union, returns self unchanged. If only one type remains after subtraction, returns it directly (unwrapped). If all members are removed (e.g., Union(Array(String), Array(Number)) minus Array), returns Type::Never to signal an unreachable code path.

pub fn is_nullable(&self) -> bool

Checks if this type is nullable (is None or a Union containing None).

pub fn is_never(&self) -> bool

Checks if this is the bottom type (never/unreachable).

pub fn is_var(&self) -> bool

Checks if this is a type variable

pub fn is_concrete(&self) -> bool

Checks if this type contains no free type variables (is fully concrete)

pub fn is_union(&self) -> bool

Checks if this is a union type

pub fn as_var(&self) -> Option<TypeVarId>

Gets the type variable ID if this is a type variable

pub fn apply_subst(&self, subst: &Substitution) -> Type

Substitutes type variables according to the given substitution

pub fn free_vars(&self) -> Vec<TypeVarId>

Gets all free type variables in this type

pub fn can_match(&self, other: &Type) -> bool

Checks if this type can match with another type (for overload resolution).

This is a weaker check than unification - it returns true if the types could potentially be unified, but doesn’t require them to be identical. Type variables always match.

pub fn can_branch_unify_with(&self, other: &Type) -> bool

Strict branch compatibility check for if-expression unification decisions.

Unlike can_match, this treats an unresolved type variable (Var) as incompatible with any known concrete type. This is used when deciding whether if-expression branches should be unified or placed in a Union type: if one branch has None in a tuple element position and another has Var (which might resolve to Number), we conservatively choose Union to avoid a spurious unification error later.

• Var(a) vs Var(b) → true (both unknown; let unification decide)
• Var(a) vs concrete → false (Var might not match the concrete type)
• concrete vs Var(a) → false (symmetric)
• All other cases mirror can_match

pub fn match_score(&self, other: &Type) -> Option<u32>

Computes a match score for overload resolution. Higher scores indicate better matches. Returns None if types cannot match.

Scoring:

• Exact match: 100
• Union type: best match among variants (slightly penalized)
• Type variable: 10
• Structural match (array/dict/function): sum of component scores

impl Type

pub fn display_resolved(&self) -> String

Formats the type as a string, resolving type variables to their readable names. This is used for better error messages.

pub fn display_renumbered(&self) -> String

Formats the type with renumbered type variables starting from 'a.

This produces clean, sequential type variable names regardless of internal slotmap indices, which can be very large due to builtin registrations. For example, instead of 'y32 or 'x3, this produces 'a, 'b, etc.

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

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

impl StructuralPartialEq for Type