Half-open range start..end (excludes end).

Inclusive range start..=end (includes end).

Ordering — result of a comparison.

str — an immutable UTF-8 byte string view (newtype over Slice(u8)).

String literals "hello" produce str at runtime. For heap-allocated growable strings, see String.

ExprList

Type reflection metadata structs — used by Type.get_info(). StructKind — discriminant for struct flavors.

TypeFieldInfo — metadata for a single struct/object field.

TraitInfo — lightweight reference to a trait type.

TraitFieldInfo — metadata for a single trait field.

ParamInfo — metadata for a function parameter.

ForallParamInfo — metadata for a forall type parameter.

ImplicitParamInfo — metadata for a using/effect parameter.

FunctionInfo — metadata for a function type.

TraitKind — discriminant for different trait flavors.

VariantInfo — metadata for an enum variant.

TypeInfo — compile-time enum representing rich type metadata. Returned by Type.get_info() for compile-time type reflection.

FieldInfo — compile-time struct field metadata for derive rules (legacy alias).

Option — a value that may or may not be present.

Option(T) has two variants:

• .Some(value) — contains a value of type T
• .None — contains no value

Example

(x : Option(i32)) = .Some(i32(42));
assert(x.is_some(), "expected Some");
assert((x.unwrap() == i32(42)), "expected 42");

DeriveContext — context passed to derive rule functions (needs Option). Used by the derive macro to generate trait implementations.

Result — a value that is either success (Ok) or failure (Err).

Result(OkType, ErrorType) has two variants:

• .Ok(value) — contains a success value of type OkType
• .Err(error) — contains an error value of type ErrorType

Example

(r : Result(i32, str)) = .Ok(i32(42));
assert(r.is_ok(), "expected Ok");

Box — a heap-allocated, reference-counted container for a single value.

Use box(value) to allocate. Access the inner value with b.*.

Example

b := box(i32(42));
assert((b.* == i32(42)), "inner value is 42");

=== Arc === Arc — an atomically reference-counted, thread-safe container for a single value.

Use arc(value) to allocate. Access the inner value with a.*.

Example

a := arc(i32(42));
assert((a.* == i32(42)), "inner value is 42");

MaybeUninit — a wrapper that allows holding an uninitialized value.

Useful for FFI or low-level patterns where a value must be allocated first and initialized later (e.g., by a C function).

Example

extern "C",
  time_t : Type,
  time : fn(timer: ?*(time_t)) -> time_t
;

uninitialized_timer := MaybeUninit(time_t).new();
ptr := uninitialized_timer.as_ptr();
time(.Some(ptr));
timer := uninitialized_timer.assume_init();

Pointer iterator for Array(T, N) - yields *(T) pointers to each element Used by Array.iter()

Pointer iterator for Slice(T) - yields *(T) pointers to each element Used by Slice.iter()

FutureState — the state of an async Future.

JoinHandle — a handle to a spawned async task. Wraps a raw pointer to the spawned future's state machine. Generic over T, the return type of the spawned task.

Comptime trait — indicates a type that can be used at compile-time. Examples: i32, bool, Type, comptime_int, comptime_float, comptime_string. Non-examples: int, ushort (runtime-only types).

Runtime trait — indicates a type that can be used at runtime. Examples: i32, bool, *(i32), void. Non-examples: comptime_int, comptime_float, comptime_string, Type (compile-time-only types).

Send trait — indicates a type that can be safely transferred between threads.

Acyclic trait - indicates a type that cannot form reference cycles. Types that implement Acyclic don't need cycle collection tracking. Primitive types, value types without object fields, and objects that don't reference back to themselves (directly or indirectly) are Acyclic.

The Rc trait means the type is reference counted object type.

Dispose trait - defines a dispose method for cleaning up resources.

Index trait — enables container(idx) subscript syntax at runtime. The Idx parameter is the index type (e.g., usize, Range(usize)). Implementations must define an Output associated type and an index method.

ComptimeIndex — compile-time indexing trait for constant expressions.

RangeOp trait — enables start..end operator syntax.

RangeInclusiveOp trait — enables start..=end operator syntax.

Add trait — enables lhs + rhs operator. Parameterized by Rhs type.

Compile-time variant of Add.

Sub trait — enables lhs - rhs operator.

Mul trait — enables lhs * rhs operator.

Div trait — enables lhs / rhs operator.

Mod trait — enables lhs % rhs operator.

BitLeftShift trait — enables lhs << rhs operator.

BitRightShift trait — enables lhs >> rhs operator.

Exponentiation trait — enables lhs ** rhs operator.

Negate trait — enables unary -value operator.

LogicalNot trait — enables !value boolean negation.

BitNot trait — enables ~value bitwise complement.

BitAnd trait — enables lhs & rhs bitwise AND.

BitOr trait — enables lhs | rhs bitwise OR.

BitXor trait — enables lhs ^ rhs bitwise XOR.

Eq trait — enables == and != comparison operators. The != method has a default implementation that negates ==.

Ord trait — enables <, <=, >, >= comparison operators. Requires the type to also implement Eq.

Hash trait - Similar to Rust's std:#️⃣:Hash

This trait defines the ability to hash a value into a u64. Types that implement Hash can be used as keys in HashMap and HashSet.

The hash function should satisfy:

1. Deterministic: The same value always produces the same hash
2. Consistent with Eq: If a == b, then hash(a) == hash(b)

Note: Unlike Rust which uses a Hasher trait for incremental hashing, we use a simpler approach where each type directly produces a u64 hash.

Clone trait — deep-copy a value.

Isolation trait — runtime check whether a value can be safely transferred.

Iterator trait — lazy, pull-based sequence traversal.

IntoIterator trait — convert a collection into an iterator.

TryFrom trait — fallible conversion from one type to another.

TryInto trait — fallible conversion of Self into another type.

IO module — the async runtime effect.

Provides io.async, io.await, io.spawn, and io.state operations. Automatically injected into main when declared with using(io : IO).

Allocate a value on the heap, returning a Box(V).

Allocate a value inside an Arc, returning an Arc(V).

if macro — expands to cond(condition => then, true => else).

Example

if(x > 0, println("positive"), println("non-positive"));

try macro — unwrap a Result, returning early on Err.

Example

value := try(might_fail());

for macro — iterate over a collection using the Iterator trait.

Example

for arr.iter(), (value) => {
  printf("value %d\n", value.*);
};

The unsafe module — provides low-level escape hatches.

Var — compile-time variable introspection utilities.

Provides macros for querying metadata about a variable at compile-time, such as ownership status and alias information.