File-level privilege flag for the pragma(...) builtin. Declared at the top of a Yo file (e.g. pragma(Pragma.AllowUnsafe);) to opt the file into compiler-recognized behaviors. See plans/MEMORY_SAFETY.md.

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

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

Ordering — result of a comparison.

RawSlice — a plain ptr+len pair for PRIVILEGED (pragma'd) code: C interop and std internals. Carries a raw pointer, so the existing raw-pointer gates apply: safe code cannot name or construct it. Replaces the builtin Slice(T) for internal plumbing (plans/SLICE_REWORK.md step 4).

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();

IterPair — a two-element product type used by enumerate and zip.

Lazy iterator that maps each element through a function F.

Created by calling .map(f) on any iterator. I is the source iterator type, B is the output element type, F is the mapper closure type satisfying Fn(item : A) -> B.

Lazy iterator that skips elements for which the predicate returns false.

Created by calling .filter(pred) on any iterator. I is the source iterator type, F is the predicate closure type satisfying Fn(item : *(A)) -> bool.

Lazy iterator that yields at most n elements from the source.

Created by calling .take(n) on any iterator.

Lazy iterator that skips the first n elements of the source, then yields all remaining elements.

Created by calling .skip(n) on any iterator.

Lazy iterator that pairs each element with its zero-based index.

Created by calling .enumerate() on any iterator. Yields IterPair(usize, A) values where _0 is the index and _1 is the original element.

Lazy iterator that combines two iterators element-by-element into pairs. Stops as soon as either iterator is exhausted.

Created by calling .zip(other) on any iterator. Yields IterPair(A, B) values.

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.

Io module — the async runtime effect.

Provides io.async, io.await, io.spawn, and io.state operations. Automatically injected into main when declared with io : Io.

Comptime trait — indicates a type that can be used at compile-time. Examples: i32, bool, Type, comptime_int, comptime_float, comptime_str. 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_str, 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.

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.

for(coll, (x) => body) — calls coll.into_iter() and binds x to each yielded value. The collection is moved into the iterator; object elements are handles, so mutating x in the body mutates the element in place.

The old borrow form for(coll, ref(x) => body) was REMOVED: it required refs into reallocatable storage, which is no longer expressible. Object elements mutate in place through the value handle; struct elements use an index loop with get/set.

Combinator chains (coll.into_iter().map(f), etc.) work transparently: a blanket into_iter impl on Iterator (below) makes every iterator its own IntoIterator.

Examples

// Object elements — mutate in place through the handle.
for(names, (s) => {
  s.push_str("!");
});

// Consume an iterator chain.
for(list.into_iter(), (x) => print(x));

The unsafe module — provides low-level unwind 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.