Type Constructors & Aliases

This page explains how to define new types in TypR using type, opaque, and typeconstructor.

Transparent aliases (`type`)

A type alias creates a transparent name for an existing type. The alias and its underlying type are fully interchangeable:

type Meters <- int;
type Person <- list { name: char, age: int };

# These are equivalent
let d: Meters <- 42;
let d: int <- 42;

Transparent aliases are useful for documentation and clarity — they give semantic meaning to raw types without changing behavior.

Opaque aliases (`opaque`)

An opaque alias hides the underlying type from external code. This provides stronger encapsulation:

Inside the module that defines it, the underlying type is still visible:

module Distance {
    @pub opaque Meters <- int;
    @pub let make <- fn(v: int): Meters { v };
};

Outside, the boundary holds:

This example does not compile It shows what TypR rejects, on purpose.
# --- setup: the module above ---
module Distance {
    @pub opaque Meters <- int;
    @pub let make <- fn(v: int): Meters { v };
};

let d <- Distance$make(42);
let n: int <- d;   # the opaque type does not convert back on its own

Opaque types enforce a boundary: code outside the module where the alias is defined cannot freely mix the opaque type with its underlying type. This prevents accidental misuse of domain-specific values.

Generic type definitions

Both type and opaque support generic parameters using angle brackets <T>:

type Option<T> <- .Some(T) | .None;
opaque Factor<L> <- int;

note

Generic parameters use <T> (angle brackets), not [T] (square brackets). Square brackets are reserved for array dimensions and index generics.

Phantom parameters

A phantom parameter appears in the type definition but not in its body. It exists only for type-level tracking:

opaque Factor<L> <- int;   # L never appears in the right-hand side

Phantom parameters are useful when you need to distinguish between values that have the same runtime representation but different semantic meanings. The constraint is enforced at compile time through signatures.