std/core

The built-in methods of T[]. Bodyless: provided by the compiler's array ops, not a Vader body. T is the element type.

A fixed-width natural (unsigned) big integer : little-endian base-2^32 limbs. Zero is any run of zero limbs: [] usually, [0] after a / that leaves nothing in the top limb.

BigInt :: u32[] is a distinct newtype (array-backed) : the structural array ops (index, len/push, for-in, [...] literals) forward to the backing array, while the scalar arithmetic is overloaded on the nominal type: bigint * u32 (Mul<u32>) and bigint / u32 → [quotient, remainder] (Div<u32, [BigInt, u32]>). mul_add_small (×+add) has no operator form and stays a method.

Opaque handle to a GC-managed contiguous byte region. Carries no fields : the backing bytes live in a dedicated runtime object (the BUFFER sentinel type), addressed only through the @intrinsic methods below. Never built via a struct literal: allocate with new_byte_buffer(n).

Convert a value to its canonical string form. Drives compile-time string interpolation ("${value}") and the print / println family in std/io. Every primitive type ships an @intrinsic impl ; user types opt in by declaring their own to_string.

Structural equality. Powers the == and != operators : a != b is !a.equals(b), so the two cannot disagree.

Total ordering. Powers < / <= / > / >= : a < b is a.compare(b) < 0, so an impl provides compare alone and the four operators cannot disagree with it.

compare(a, b) must return:

• < 0 when a is strictly less than b,
• = 0 when they're equal,
• > 0 when a is strictly greater than b.

Hash codes for MutableMap / MutableSet keys: equal values (Equals), equal hashes. A map's first probe reads the LOW bits; a key varying only in high ones should mix them down.

Advance one position along a discrete sequence. Sole obligation : step() returns the next value after self. Used by Range[T : Step & Comparable] implements Iterator<T> so a single generic impl covers every integer width plus char: concrete + 1 / codepoint-bump logic lives in each primitive's Step impl instead of being repeated per Range<T> impl.

Explicit deep copy. clone(x) (free function) dispatches into this when T: Clone ; primitive types don't need it (value-typed by default).

Type-to-type conversion. Two surfaces :

• Implicit : when a value of type S flows into a slot expecting Target and S implements Into<Target>, the compiler inserts value.into() at the boundary. Sites : call args with a typed parameter, return values, x: T = v, struct-literal fields, and the receiver of a method call no function takes as is.
• Explicit : Target(value), the same Type(value) syntax that performs primitive numeric casts (u32(x), i64(x)). When Target is a user type, the compiler routes the call through the matching Into impl instead of emitting a primitive cast.

Coercion is not transitive (A → B → C never auto-chains), and T implements Into<T> is forbidden. SPEC §4 Type coercion via Into gives the full rules, among them which targets convert.

+ dispatch. Numeric primitives use the built-in bytecode op directly ; user types implement Add to opt into the operator form. Rhs is the right-operand type and Out the result: both default to Self, so the common homogeneous case is just implements Add; heterogeneous operators (e.g. Instant implements Add<Duration, Instant>) spell the params.

- dispatch. See Add.

* dispatch. See Add.

/ dispatch. See Add.

% dispatch. See Add.

The additive identity of a type: what a sum of no elements is. A static member : called on the type, T.zero() in a body bounded by T: Zero.

The multiplicative identity of a type: what a product of no elements is. A static member, like Zero.zero.

Bit-level view of a float as its raw IEEE 754 integer pattern. This is NOT a numeric conversion : u64(x) truncates the VALUE (3.7 → 3), whereas x.to_bits() returns the exact bits (3.0 → 0x4008000000000000). The inverse is BitsFloat::from_bits. Powers shortest-double formatting and any float bit-fiddling, with no per-target runtime symbol (lowers to a union cast). Mirrors Rust's f64::to_bits / f64::from_bits (deliberately distinct from the as/cast conversion).

Inverse of FloatBits: reconstruct an f64 from a raw IEEE 754 bit pattern.

32-bit analogue of FloatBits : the raw IEEE 754 u32 bit pattern of an f32 (NOT u32(self), which truncates the value). Powers the pure-Vader shortest-f32 formatter (Ryu f2s). Inverse is Bits32Float::from_bits.

Inverse of Float32Bits: reconstruct an f32 from a raw IEEE 754 u32 bit pattern (NOT f32(self), which widens the integer value).

Indexed read: a[i] dispatches through this when a isn't a built-in array. I is the index type, T the element type.

Indexed write: a[i] = v. Symmetric with Index.

Membership test. x in coll desugars to coll.contains(x) ; x !in coll desugars to !coll.contains(x). Implemented by Range (for the integer / char ranges), MutableMap, MutableSet, and any user type that wants infix in support.

How one iterator step ended, see Iterator.next.

Pull-based iterator. The lowerer dispatches for x in iter through the impl table: users never call next directly. What consumes one (count, last, collect, find...) is a free function over Iterator<T> in std/iter, a for over its argument.

next() hands back the element and whether the iteration goes on. A PAIR rather than a wrapper around a nullable: the pair crosses the call in registers instead of through the heap, and it makes T = U | null unremarkable: Continuation says whether there is an element, so a null ELEMENT is just an element.

The element beside Continuation.Stop is INDETERMINATE. An implementation hands over whatever T it has rather than manufacturing one, and no consumer may read it before testing the Continuation.

Base trait for every error type usable in T | Error returns. Any struct implementing Error participates in such error unions ; a caller narrows on it (if r is Error) and returns it to propagate.

Sentinel returned by Async.resume when the coroutine suspended (it awaited something not yet ready) rather than completing. T | Suspended stays unambiguous because Suspended is a distinct nominal type, where Iterator.next carries the same information BESIDE the element instead, in its Continuation.

The awaitable produced by calling an async fn: await e unwraps Async<T> to T. Each async fn's synthesised state struct implements it (wired in lowering). Carries no error semantics of its own ; a fallible async fn returns Async<T | SomeError>.

One field of a struct type as exposed by the @fields(T) reflection intrinsic. name is the source-level identifier ; type carries the field's declared type as a runtime type value.

Range produced by 0..<n / 0..=n and 'a'..='z'. Generic over the bound type so integer ranges (every signed / unsigned width plus i64 / i64) and char ranges share a single struct. The cursor field is advanced by each next call via implicit struct-ref mutation.

A signed 8-bit integer.

A signed 16-bit integer.

A signed 32-bit integer, the type of an integer literal nothing else types.

A signed 64-bit integer, the type of a length, an index and a size.

An unsigned 8-bit integer.

An unsigned 16-bit integer.

An unsigned 32-bit integer.

An unsigned 64-bit integer.

The scanned parts of a decimal float : significand w (first <= 19 significant digits), power-of-ten exponent q, sign, and whether more than 19 significant digits were seen (needs the slow path, not yet built).

Build an array of n elements, calling make once per slot.

The complement of [v] * n, which repeats ONE reference into every slot and so cannot build n distinct objects (see W0013).

Build an array of n elements, calling make(i) for slot i.

The positional twin of filled : reach for it when an element depends on where it sits, and for filled when it doesn't.

Whether self and other hold equal elements in the same order : the same length, and self[i] == other[i] at every index.

Whether other holds the elements of self in some order, each as many times. Quadratic : each element of self is looked for among the elements of other not yet matched.

Whether every element of other is in self. Each counts once : [1].contains_all([1, 1]) holds.

Whether self and other share no element.

Multiply by a small scalar and add a small scalar : self * mul + add.

One limb pass, O(n). The single primitive behind the ×5 power-of-five step and the ×10 + digit decimal accumulation.

floor(self / d), discarding the remainder.

Left-shift the whole big-int by bits (>= 0).

True when every limb is zero. The generic is_zero does not apply : BigInt has no Equals, and its zero has several forms.

Whether self is its type's zero, compared with ==.

True when any set bit lies strictly below bit position pos.

Bit length : position of the highest set bit + 1 (0 for zero).

The 64 bits starting at bit offset off, little-endian.

Top 128 bits (floor), normalized so bit 127 is set.

2^k as a BigInt.

Left-shift a raw 128-bit value (hi:lo) by s in [0, 127].

Operates on a two-word value rather than a BigInt: a shared helper for top128 and the dtoa split rows.

Allocate a Buffer of cap zeroed bytes. Lowers to the buffer.new op.

Iterate a T[]. for x in arr has its own fast path and never comes here; this is what an array COERCED to Iterator<T> becomes.

A generator rather than a hand-written impl, and that is forced rather than chosen: next must pair its element with a Continuation, and on Stop there is no T to pair: an empty array holds none, and T promises nothing that would build one. A generator's next is synthesised by the lowerer, which pairs the type's zero; a ref slot takes NULL whatever T says, and that is expressible there and not here.

Scan a decimal float string into DecimalParts, or null on malformed input (empty, no digits, a bare exponent, trailing junk). w holds the first 19 significant digits ; leading zeros are skipped and q tracks the decimal point + exponent.

Eisel-Lemire : the packed IEEE-754 MAGNITUDE bits of w * 10^q (sign not applied), correctly rounded for w with <= 19 significant digits. w == 0 yields +0 ; q below -342 yields 0, above 308 yields inf.

Parse a decimal float string to f64, or null on malformed input. Correctly rounded : the Eisel-Lemire fast path for <= 19 significant digits, an exact big-int slow path for more.

Intern the buffer's leading len bytes as a string (one atom-table copy).

Byte length of s (its UTF-8 byte count), an @intrinsic read straight off the interned atom. String-only: a u8[] uses .len() directly.

The byte at index i of s: an @intrinsic header-free read straight off the interned atom, no read-only u8[] view materialised: how code reads a string's bytes, the peer of byte_len for the [i] case.

The bytes of s from offset start up to end, excluded, as a string: an @intrinsic slice of the interned atom, nothing copied. Offsets count bytes, where s[i] counts codepoints. Like any slice, offsets past the end clamp to it, and an end before start gives the empty string.

Whether every byte of s is ASCII (below 0x80): each byte is then one codepoint, and a byte offset is a codepoint index. The runtime records it when the string is made, so the answer reads no byte.

Write s's bytes at off ; return off + s.byte_len().

Write the signed decimal digits of n at off ; return the offset past them.

Write the unsigned decimal digits of n at off ; return the offset past them.

Write "true" / "false" at off ; return the offset past it.

Materialise a string from verbatim UTF-8 bytes: the canonical bytes→string primitive (inverse of bytes). Host intrinsic backed by vader_string_as_string (the runtime symbol kept its name) ; O(1) on a borrowed bytes() slice, O(n) on a packed array, no UTF-8 validation.

Borrow the UTF-8 bytes of a string as a read-only u8[] view: the canonical string→bytes primitive, inverse of bytes_to_string. Host intrinsic backed by vader_string_bytes_view (no new runtime symbol) ; a zero-copy borrowed view of the interned bytes on native, read in place on the VM until a write copies it. To read a string's bytes, byte_len, byte_at and byte_slice take the string itself.

True when b is a UTF-8 continuation byte (0x80..0xBF): the trailing bytes of a multi-byte sequence, never a leading byte.

Encode a Unicode codepoint to its UTF-8 bytes (pure arithmetic), for interning via bytes_to_string or appending into a byte buffer. codepoint_at_byte reads back what this writes.

Decode the UTF-8 codepoint at byte offset i of a string, read in place: the codepoint and the bytes it spans. Advance a byte cursor by that width to land on the next codepoint. Malformed bytes decode as U+FFFD, spanning the longest prefix of a well-formed sequence and at least one byte: the substitution Unicode recommends and WHATWG decoders apply. Every codepoint walk in the standard library steps this way, so len, s[i] and for c in s agree on any bytes.

Decode the non-ASCII codepoint that b, the byte at offset i of s, leads: codepoint_at_byte past its ASCII test, for a walk that has read the byte.

Codepoint length of s: the number of Unicode codepoints, not bytes. In the prelude, so s.len() works without importing std/string. Counts the steps of codepoint_at_byte over the bytes, so it is the number of codepoints for c in s yields. O(1) on an ASCII string, else O(n) in the byte length.

128-bit powers of five, POW5_128[2*(q+342)] = high word, +1 = low word. Computed at compile time ; see the file header for the algorithm.

Unicode replacement character (U+FFFD): the standard stand-in for an undecodable byte or an unpaired UTF-16 surrogate.

Membership for arrays: v in arr / v !in arr dispatch here. Linear scan via Equals. As an impl member, the monomorphised == devirtualises to the element's primitive comparison on every backend. Blanket impl (orphan rule : Contains is std/core's, T[] isn't), mirroring the Into blanket above.

[lhs] * n: array repeat / preallocation, the * operator on arrays. [v] * n repeats the elements n times ([7, 9] * 2 → [7, 9, 7, 9]) ; the empty-LHS form [] * n is the preallocation primitive (length 0, capacity n: the with_capacity replacement). * on an array dispatches here through the normal trait lookup : a concrete array matches this blanket via the "[]" impl-key (impl_base_key), and the lowerer devirtualises BOTH forms to the array.repeat intrinsic, which preserves the preallocation form and shallow ref-element semantics. The body is the logical repeat fallback for any path the devirt can't statically reach. The return is a fresh array the caller owns. Blanket impl (orphan rule : Mul is std/core's, T[] isn't), mirroring Into / Contains.

An array's text: [, then each element's own Display separated by , , then ]: [1, 2], [a, b], [[1], [2, 3]]. Each element is rendered once, then written into one buffer sized to fit them all.

s[i]: the codepoint at codepoint index i, found by walking s from its start; in an ASCII string, the byte at i. Traps past the last codepoint, where the walk lands on the length.

s[lo..<hi] and s[lo..=hi]: the codepoints of a range, as a string; in an ASCII string, the bytes of the range. Bounds past the end clamp to it, and a range ending before it starts gives the empty string.