Envzn Reference

Every name a developer looks up, in one index: keywords, primitive types, and the types the shipped modules expose. An entry says what the name is, points at the Constitution section that governs it, and links to the API page that details it. It deliberately does not restate a rule — the specification owns the rules, and a reference that paraphrases them is a second source of truth waiting to disagree.

Keywords (140)

`ABSTRACT`

keyword

VALUE CLASS (3rd type-kind, §I.J.vi) = a class with value identity + inline storage: methods + generics + IMPLEMENTS, but value-copied and stored inline (no _ev_unique handle). Fields read with ., methods called with -> (like number/complex). DynamicString/DynamicByteBuffer are NOT examples any more — they became ordinary heap classes on 2026-08-24, when the SBO removal left them with no inline storage. Still a class → bind with := (plain = is E3023), uniformly whether strict (all-value fields) or managed (owns heap → compiler synthesizes the deep-copy ctor). Inheritance leaf: IMPLEMENTS yes, EXTENDS/be-extended no (E1132); satisfies interfaces for generic constraints but can't be boxed behind an interface handle in V1 (E1133). VALUE can't combine with ABSTRACT/SINGLETON. (This bullet used to end by calling DynamicString/DynamicByteBuffer value classes, contradicting its own opening sentence four lines earlier — they stopped being value classes on 2026-08-24.)

Specification: I.B — Definitions and Notation

Diagnostics that name it: E1099, E6003, E6006, E6007, E6011, E6020, E6022, E6026 (+4 more)

`ALIAS`

keyword

ALIAS — file-scoped un-qualification (§I.N.d.iv, #48). At the top of a file (after MODULE, before any CLASS/INTERFACE/NAMESPACE), bind a qualified name to its bare short name for that file only. Three forms by qualifier: ALIAS mda::TextColumn (::) → bare TextColumn is the dep type file-wide (decls/CREATE/MATCH/PANIC); ALIAS Math.cubeRoot (.) → bare cubeRoot(x) is Math.cubeRoot(x); ALIAS Math (bare namespace) → every Math function bare-callable. Pure rewrite to the FQN before file-merge — no new scope, no runtime, no visibility change. Guards: target must be real (E2107); short name may not collide with a local type/method or another alias, incl. a whole-namespace import that brings in a colliding name (E2108 — ALIAS never shadows).

Specification: I.N — Modules and Linkage

`AND`

keyword

INTERFACE composes with EXTENDS, comma-separated — and NEVER with IMPLEMENTS (E6090). INTERFACE Dictionary[K, V, H] EXTENDS Cloneable, Equatable OF Dictionary, Comparable OF Dictionary — one or more parents, commas, not AND (2026-09-14; AND is the template-qualifier operator, TEMPLATE: GIVEN TYPE T IS (Cloneable AND Comparable), and means nothing on an EXTENDS line where every parent always applies). An interface is a contract, so it implements nothing. A CLASS is the mirror image: exactly one EXTENDS parent (E6018), many IMPLEMENTS interfaces, also comma-separated. Reaching the same ancestor method by two paths with an identical signature is a diamond — one contract, kept once, no error; same name + different params is an overload; same name + same params + a different result is E6091.

Specification: I.F — Expressions

`AS`

keyword

Primitives carry no methods, no wrapper classes (no Integer/Float64). Convert with the INTO/AS operators (the Convert singleton is deleted — 2026-06-07): x INTO T = lossless/widening, total (int32 INTO int64, num→String); x AS T = lossy/narrowing, fallible → (T value | STATUS s) (int64 AS int32). Conversions live in CONVERSIONS hosts (PrimitiveConversions/NumberConverter/FloatConverter/TextConverter/CharConverter) + NAMESPACE codecs called with . (HexCodec.toHex(bb)/Base64Codec./ByteOrderCodec./UTFCodec.). int/integer are aliases of int64; uint of uint64; float of float32. boolean holds TRUE/FALSE (never bool). Any conversion question — which operator, what's valid, what it returns, format auto-convert — see docs/CONVERSIONS.md (the full AS/INTO matrix + per-host detail).

Specification: I.D — The Type System

Diagnostics that name it: E2087, E2088, E2089, E2105, E2106, W10026

`ASHIFT`

keyword

Specification: I.F — Expressions

`ASSERT`

keyword

Specification: I.F — Expressions

`ASSERT!`

keyword

Bare + − * ^ ! / unary − that overflows a fixed-width integer — signed AND unsigned (int8..int128, uint8..uint128) — raises a tier-2 MathError PANIC (CLEANUP-unwinds, RECOVER-catchable for graceful shutdown; ALWAYS ON — not stripped under -prod, unlike tier-3 ASSERT!). A wrapped size is the classic exploit; the floor forbids it. Same tier-2 MathError covers integer ÷0 (/ %) and shift-past-width. Two type exceptions: number promotes up its ladder (never panics on int overflow); decimal128 rounds within precision and panics only on ÷0/magnitude(exponent)-overflow. Floats are IEEE-untrapped: float16/32/64 overflow → ±Infinity, underflow → signed 0, NO panic (float32 ≡ float64 — same standard). # hash-combine is EXEMPT (modular by design). Intentional wrap = the greppable operators &+ &- &* (Swift-style; modular add/sub/mul, integer-only — a float/number/decimal128 operand is E2134). Each lowers to a single-instruction ev_wrap* intrinsic; they are the ONLY sanctioned modular arithmetic — never rely on a bare op wrapping. (Not a method: an operator carries no namespace reference, so it introduces no kernel-class dependency.) Enforcement for the panicking + − * is the checked lowering (_checked_arith, which also checks / % <<), and it has LANDED. The interim -fwrapv is gone — from the emitter (Bug #290) and from every build as of 2026-08-26 — so signed overflow is neither defined nor silent: it PANICs. Author to the PANIC contract; there is no wrap to fall back on.

`ATTACHED`

keyword

`AUTO`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E3027, E3028, E6056, E6057, E6066, E7029

`BAND`

keyword

char family: char≡char32=code point (U+0000..10FFFF); char8=UTF-8 unit, char16=UTF-16 unit. Cross-width = explicit INTO/AS (via CharWidthConverter); an implicit cross-char-type conversion (e.g. char16 u = someChar8) warns (W10095) — every pair except char16→char32 (same scalar). (--no-clang-char-warnings silences clang's parallel warning, not Envzn's.) Never write bare char ambiguously; String ring is char32. binary = the raw octet (distinct from char, and — since byte was retired 2026-08-29 — the only octet type; a small number is uint8). Octet rules (I.D.i(c.i)): literals are hex or binary only (0xC3, 0b1100_0011 — never 195, W2136); operators are =, +/-, BAND/BOR/BXOR/BNOT/RSHIFT/LSHIFT, and the six comparisons — no * / % ^ (W2135), because +/- move within the octet space (c - 0x30 decodes an ASCII digit) while scaling assumes a magnitude. Shift count is uint8 (W2137); a literal count adopts it, and a shift ≥ 8 yields 0x00.

Specification: I.D — The Type System

`BEQUALS`

keyword

Specification: I.F — Expressions

`BIND`

keyword

Specification: I.N — Modules and Linkage

Diagnostics that name it: E2090, E2091, E2092, E2095, E2096, E2097, E2100

`BLITTABLE`

keyword

Specification: I.J — Aggregates and Iteration

`BNEQUALS`

keyword

Specification: I.F — Expressions

`BNOT`

keyword

Specification: I.F — Expressions

`BOR`

keyword

Specification: I.D — The Type System

`BREAK`

keyword

Loops: FOR x IN coll (binds non-owning, locks coll vs mutation) · FOR i = 0 TO 10 STEP 2 (TO inclusive, UNTIL exclusive) · FOR (int i = 0; i < n; i++) — the NORMAL FORM of the C-style loop (Brian, 2026-08-25): parens, and i++. Only place with ;. Reach for it when you need a counter of a SPECIFIC width, since the range form's counter is int64 and has no type slot · REPEAT n { } · REPEAT { } (bare = infinite, leave by BREAK).

Specification: I.H — Control Flow

Diagnostics that name it: E4004, E4023

`BXOR`

keyword

Specification: I.H — Control Flow

`CALLED_BY_EMITTER`

keyword

Specification: I.N — Modules and Linkage

`CATCH`

keyword

Specification: I.M — Error Handling

Diagnostics that name it: E1006, E4016, E4017, W10013, W10042

`CLASS`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E1008, E1024, E1099, E1100, E1101, E1102, E1103, E1132 (+23 more)

`CLEANUP`

keyword

LABEL <name> <loop-or-block> — name it, then BREAK <name> / CONTINUE <name> jumps multiple levels. Prefixes ANY loop form or a bare { } (the early-exit ladder). The jump is lexical — forward to just past the block, or back to the named loop's next iteration; it never enters a block, moves sideways, or leaves the method. Unwinds properly: destructors, every CLEANUP, and any FINALLY it leaves all run. Names are unique per CLASS (E4038) even across methods. Not allowed inside a FINALLY (E4037) or across PARALLEL/CONCURRENT/LAMBDA (E4036); CONTINUE needs a loop, not a block (E4035).

Specification: I.I — Memory and Ownership

Diagnostics that name it: E2076, E3005, E3022, E6004, W10031

`CONCURRENT`

keyword

Specification: I.L — Concurrency

Diagnostics that name it: E4090, E4100, E4101, E4102, E4105, E4109, W4106, W4108

`CONSTANT`

keyword

Fields public + immutable by default (2026-08-14, gh #215 — visibility NARROWS, it never widens); modifiers PRIVATE/PROTECTED/INTERNAL, SHARED, CONSTANT. A field, CONSTANT, or method declaring none of PRIVATE/INTERNAL/PROTECTED is public — PUBLIC is a reserved word that parses NOWHERE (absent from the field-modifier set in parse/parser/decl_class.py and the method set in decl_method.py), so writing it is E1008, not a no-op. Immutability is the axis that carries the safety: every write path is a named MODIFY method. Field visibility is enforced by the ANALYZER, on reads AND writes — PRIVATE by E6009, module-scoped INTERNAL by E6034 (2026-08-12; the write side was unreachable before then, which is how gh #205's a._length = 100000 reached clang). METHODS are NOT checked — E6009 is oop:private-field and never inspects a call, so a cross-class PRIVATE method call falls through to a raw clang reject (#213) and a kernel PRIVATE method is emitted public: in EV_*.hpp and is callable from any module with no error at all (#214) — don't read a green build as proof a method is properly encapsulated. In the emitted C++ a PRIVATE field lands in private: as defence in depth, but an INTERNAL one lands in public: on purpose and permanently — C++ has no way to say "same module", protected: means subclass, and a module-mate that isn't a subclass legitimately reads it. Don't "fix" that. A STRUCT field may carry no visibility modifier at all (E6030, at the declaration). Class-typed fields must be set on every INIT path (no silent EMPTY). REFERENCE = non-owning (use for back-pointers to avoid ownership cycles). VOLATILE is retired on class fields (V1, 2026-05-13) — reserved word only; route shared mutable state through MODIFY methods + Mutex[T]/AtomicX/SHARED CLASS (a STRUCT field may still be VOLATILE, I.J.iv).

Specification: I.E — Declarations and Bindings

Diagnostics that name it: E1024, E1080, E1081, E1082, E1083, E1084, E1086, E1107 (+4 more)

`CONTINUE`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E4005

`CONVERSIONS`

keyword

Specification: I.O — The Standard Library Surface

Diagnostics that name it: E2088, E2089, W10026

`CREATE`

keyword

= | bind a value, never object ownership. Primitive/value-class/STATUS/enum: any expr (bit copy). String: a string literal only. Other class: EMPTY only. Any CREATE/->clone()/copy under = is an error (E2020 String, E3023 other). |

Specification: I.J — Aggregates and Iteration

Diagnostics that name it: E1084, E1131, E1133, E2016, E2057, E6027

`DEFAULT`

keyword

REMOVED 2026-08-02 — all are IF/ELSE IF now (E4030): WHEN ==0: · WHEN 1 TO 10: · WHEN 5: (any literal/list) · WHEN .method(): / WHEN NOT .field: · WHEN x IF guard: · subjectless MATCH { WHEN <bool>: } · DEFAULT: (a named closed set has nothing left to catch; DEFAULT survives ONLY on the compile-time WHEN IS/IMPLEMENTS form, where the else arm is mandatory). An int32/char/String is not a closed set — that is the whole test. Deep IF-chains are a design smell: reach for polymorphism, not a longer chain.

Specification: I.H — Control Flow

Diagnostics that name it: W10004

`DEPRECATED`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E6004

`DERIVED`

keyword

Specification: I.P — Serialization and Reconstruction

`DETACHED`

keyword

Specification: I.L — Concurrency

Diagnostics that name it: E4109, W4106

`DIRTY`

keyword

Specification: I.I — Memory and Ownership

`DO`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E1030, E1090, W10001

`DUPLICATE`

keyword

Read live exemplars first: LinkedList.ev (splice/ownership), Stack.ev/Queue.ev (compose-on-Array), ChainedHashEntry.ev/DefaultHasher.ev/Hasher.ev (generic dispatch + DUPLICATE).

Specification: I.I — Memory and Ownership

Diagnostics that name it: E3027, E3028, E6056, E6057, E6058, E6066, E7029

`ELSE`

keyword

Conditional compilation (#5): WHEN Build IS DEBUG { } ELSE { } / WHEN Build IS RELEASE { } ELSE { } — compile-time; the unmatched arm is removed before analysis (never type-checked/emitted). Posture = RELEASE iff -prod (or --build release), else DEBUG. Positive-identity only, mandatory ELSE. (Platform / WHEN FEATURE forms designed, not yet implemented.)

Specification: I.H — Control Flow

Diagnostics that name it: E1095, E4010

`EMPTY`

keyword

Specification: I.B — Definitions and Notation

Diagnostics that name it: E2005, E2010, E2076, E2080, E4003, E5006, W10046

`ENCRYPTED`

keyword

Specification: I.I — Memory and Ownership

`ENUM`

keyword

MATCH = exhaustive dispatch over a CLOSED SET, and every arm BINDS (§I.H.v(a)). Exactly three closed sets, because they are the only things the compiler can enumerate: a GROUP (types) WHEN Circle c: · a dev ENUM (cases) WHEN NORTH: · a STATUS (kinds) WHEN FAILURE(msg): — STATUS is not special, it is the built-in instance of the enum form. No fallthrough; statement, yields no value.

Specification: I.K — Abstractions

Diagnostics that name it: E1021, E6019, E6039, E9003, E9004, E9031, W10026, W10050

`EXCEPT`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E2112, E2113

`EXTENDS`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E1102, E1130, E1132, E2039, E4026, E6003, E6005, E6006 (+9 more)

`FAILURE`

keyword

Specification: I.M — Error Handling

Diagnostics that name it: E1007

`FALSE`

keyword

Specification: I.F — Expressions

`FEATURE`

keyword

Specification: I.H — Control Flow

`FENCE`

keyword

`FINAL`

keyword

Dictionary toolbox — Dictionary[K,V,H] is the interface and every impl is HIDDEN (2026-09-12): an impl name is a CREATE target and nothing else, so naming one as a field/param/return type is E1131. Hold the interface, CREATE the impl. Two arities: [K,V,H] generic-key — ChainedHashDictionary (unordered, general-purpose default) · RedBlackTreeDictionary (ordered key iteration, K also Comparable, O(log n)) · IntKeyedDictionary (TRUSTED-KEY FAST TIER for dense integer keys — SoA open-addressing + hash & mask, ~1.1× C; the hasher is passed in: Dictionary[int32,int64,InlineIntHasher[int32]] d := CREATE IntKeyedDictionary[int32,int64,InlineIntHasher[int32]](CREATE InlineIntHasher[int32]())) · ShallowDictionary (PARKED — multiply-shift + prime fallback; robust but ~4.6× C since a mixing index scatters, so NOT the default). [V,H] byte-key — the key is FIXED to BinaryWord, so these declare two parameters, not three: StringKeyedDictionary (the STRING/BYTE FAST TIER) and ProHashDictionary (SipHash-128 keyed, DoS-resistant for untrusted keys). BinaryWord is a borrowed byte WINDOW, not an array — a VALUE CLASS over (REFERENCE binary[] src, int64 off, int64 len). Transcode the String key ONCE (s INTO ByteBuffer → binary[]), then wrap it, keeping the array alive longer than the window: Dictionary[BinaryWord,int32,DefaultHasher[BinaryWord]] d := CREATE StringKeyedDictionary[int32,DefaultHasher[BinaryWord]]() · binary[] k := bytesOf(s) · BinaryWord kw := CREATE BinaryWord(k, 0, k.length) · d->insert(kw, v). StringKeyed's flat binary[] key pool + byte-FNV HOTLOOP hash + System->memoryCompare confirm + cached-hash reject → 0.77× C (BEATS C), pure Envzn, no FOREIGN. Interface surface = insert/insertCopy/lookup/lookupFast/remove/contains; the zero-copy slice surface (insertSlice/lookupFastSlice(buf,off,len)) and the non-pipe-XOR d[key] read are CONCRETE-only and therefore unreachable while the impls are HIDDEN. Hashers = the H slot: DefaultHasher (FNV, the no-arg default) · StringHasher · SipHasher (keyed SipHash; ProHash's built-in) · FastIntHasher (identity, regular class) · InlineIntHasher (identity VALUE CLASS — stores inline as a concrete H, for IntKeyedDictionary). Set[V,H] is FINAL, not hidden — it wraps a Dictionary and is constructed directly; same hasher choices. The cache law: a dict lookup is memory-bound — cache-fast needs identity-hash+dense keys (IntKeyed) or inline byte-dense slots (StringKeyed); every mixing/robust index (FNV/Sip/multiply-shift) scatters → ~3–4× C floor.

Specification: I.K — Abstractions

Diagnostics that name it: E6003, E6004, E6006, E6007, E6008, E6011, E6020, E6026 (+2 more)

`FINALLY`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E4006, E4007, E4009, E4017

`FOR`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E1022, E1112, E1113, E4014, E4025, E5009, E5013, E5022 (+1 more)

`FOREACH`

keyword

⚠️ Withdrawn 2026-08-18: FOREACH (reserved, E1163 — use FOR … IN) · LOOP it = coll->iterator() {…} and LOOP $_ IN coll (both gone with the old LOOP surface; for cursor control hold a kernel iterator and consume next() in a WHILE). STEP is unaffected.

Specification: I.H — Control Flow

Diagnostics that name it: E1112, E1113, E5012, E5020, W10001

`FOREIGN`

keyword

C-ABI boundary types (§I.D.x, shipped 2026-08-06): C.size_t · C.ssize_t · C.long · C.unsignedLong — four ATOMIC reserved words that contain a dot (C is not a namespace; CLASS C stays legal). They lower verbatim to the C spelling and are legal only inside a FOREIGN/FOREIGN BIND declaration (else E2143). No arithmetic, no ordering, not Numeric, no guaranteed width — that absence IS the contract. Use them whenever the C type is pointed to (LOAD C.size_t siglen → size_t*): a fixed-width primitive cannot express it, because size_t is unsigned long while uint64_t is unsigned long long on Darwin — and they SWAP on Linux, so the wrong spelling compiles on one target and fails on the other (W2146 warns on a 64-bit fixed-width LOAD). By value the old spelling merely works by implicit conversion.

Specification: I.N — Modules and Linkage

Diagnostics that name it: E1003, E1018, E2090, E2091, E2092, E2095, E2096, E2097 (+2 more)

`FOREIGN_TYPE`

keyword

Specification: I.I — Memory and Ownership

Diagnostics that name it: E1080, E3028, E3036, E3037, E6063

`FREEZE`

keyword

`FROM`

keyword

Specification: I.D — The Type System

Diagnostics that name it: E2088, E2089, W10026

`GIVEN`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E2110

`GROUP`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E2005, E2016, E2112, E2113, E3015, E6002, E6015, E6025 (+9 more)

`HIDDEN`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E1130, E1131

`HOTLOOP`

keyword

Specification: I.H — Control Flow

`IDENTITY`

keyword

Specification: I.P — Serialization and Reconstruction

`IF`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E6053, W10001, W10085

`IMPLEMENTS`

keyword

Specification: I.J — Aggregates and Iteration

Diagnostics that name it: E1095, E1096, E1097, E1130, E2068, E2115, E6005, E6013 (+3 more)

`IN`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E5009, E5013, E5022, W10001

`INDEX`

keyword

Specification: I.H — Control Flow

`INIT`

keyword

An unassigned String/ByteBuffer field reads as "", never a fault (I.E.e.i/e.ii). The compiler materialises the empty value lazily, at first read — no per-field malloc in every ctor, so an INIT that assigns the field pays for one construction, not two. You never guard a String field. (Bug #293.)

Specification: I.E — Declarations and Bindings

Diagnostics that name it: E1018, E1103, E2057, E2079, E6004, E6011, E6012, E6031 (+6 more)

`INTERFACE`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E1097, E6001, E6028, E6035, E9003, E9004, E9031, W10026 (+1 more)

`INTERNAL`

keyword

Specification: I.N — Modules and Linkage

Diagnostics that name it: E1024, E1080, E2064, E6034

`INTO`

keyword

Specification: I.O — The Standard Library Surface

Diagnostics that name it: E2087, E2088, E2089, E2105, W10026

`IS`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E1007, E1095, E1105, E2007, E2080, E4010, E6041, E6042 (+4 more)

`LABEL`

keyword

Specification: I.H — Control Flow

`LAMBDA`

keyword

Specification: I.F — Expressions

Diagnostics that name it: E1023, E7022, E7023, W10023, W10045

`LOAD`

keyword

Specification: I.N — Modules and Linkage

Diagnostics that name it: E2100, E2101, E2102

`LONG_LIVED`

keyword

`LOOP`

keyword

LOOP x IN coll WITH INDEX i { } — the ONE LOOP form: element + its zero-based int32 position. Both clauses mandatory (E1151 without WITH INDEX; use FOR … IN if you don't need i). i is read-only (E4032) and advances on CONTINUE; BREAK leaves it at the element that triggered it. WITH INDEX on any other loop keyword is E4034; the comma-pair guess LOOP i, x IN coll is E4033.

Specification: I.H — Control Flow

Diagnostics that name it: E1112, E1113, E4011, E4024

`LROTATE`

keyword

Specification: I.F — Expressions

`LSHIFT`

keyword

Specification: I.F — Expressions

`MATCH`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E1013, E1025, E2005, E4003, E4012, E4020, E6024, W10004 (+3 more)

`METHOD`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E1011, E1018, E2060, E2078, E2104, E6004, E6008, E6021 (+16 more)

`MODIFY`

keyword

=@ reference-kind: tightening OK, loosening is an error. A MUTABLE REFERENCE value may be assigned into a non-mutable REFERENCE handle (mutable → read-only); a REFERENCE may not be bound into a MUTABLE REFERENCE (E6067 — you can't widen a read-only borrow back to writable). A mirror accessor (a non-MODIFY method returning MUTABLE REFERENCE — e.g. Array subscript arr[i], Dictionary.lookupRef) propagates this automatically: reached through a const/REFERENCE receiver it returns a read-only REFERENCE, through a mutable receiver a MUTABLE REFERENCE. So REFERENCE T r =@ arr[i] always works; MUTABLE REFERENCE T r =@ arr[i] works only when arr is itself mutable. (§I.I.ix)

Specification: I.K — Abstractions

Diagnostics that name it: E1098, E1101, E1108, E2038, E2039, E2068, E6009, E6034 (+1 more)

`MODULE`

keyword

Specification: I.N — Modules and Linkage

`MOVE`

keyword

Constructors take REFERENCE, never MOVE — handing an array to a constructor never takes it away from you. The ONE exception is String.INIT(MOVE char32[], int64), which exists only so the emitter can build a string literal in one allocation; the redundant second argument is what keeps it from being ambiguous with the REFERENCE form.

Specification: I.I — Memory and Ownership

Diagnostics that name it: E2102, E3010, E3024, E3025, E3026, E3038, E6040

`MUTABLE`

keyword

Specification: I.I — Memory and Ownership

Diagnostics that name it: E1024, E1111, E1115, E1122, E2117, E3032, E6038, E6039 (+5 more)

`NAMESPACE`

keyword

Specification: I.F — Expressions

Diagnostics that name it: E1106, E1107, E1108, E1109, W10026

`NONE`

keyword

Diagnostics that name it: E5006

`NOT`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: W10018

`NO_RETURN`

keyword

`OF`

keyword

Specification: I.J — Aggregates and Iteration

`OK`

keyword

Specification: I.L — Concurrency

`OPERATOR`

keyword

Specification: I.D — The Type System

Diagnostics that name it: E2088, E2089, W10026

`OR`

keyword

Specification: I.F — Expressions

`OVERRIDE`

keyword

OVERRIDE required on concrete-parent reimpl, forbidden on abstract-impl. SUPER->m(). AUTO METHOD clone() (empty body, needs all fields Cloneable). DEPRECATED("…") advisory.

Specification: I.K — Abstractions

Diagnostics that name it: E6003, E6004, E6006, E6007, E6008, E6011, E6020, E6022 (+5 more)

`PANIC`

keyword

Specification: I.M — Error Handling

`PARALLEL`

keyword

Specification: I.L — Concurrency

Diagnostics that name it: E4105, E4109

`PARTIAL`

keyword

Specification: I.F — Expressions

`PARTIAL_SUCCESS`

keyword

Specification: I.M — Error Handling

Diagnostics that name it: E1007

`POISON`

keyword

`PRIMITIVE`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E2112

`PRIVATE`

keyword

Specification: I.E — Declarations and Bindings

Diagnostics that name it: E1024, E1080, E1117, E2064, E2116, E6009, E6030, E6039 (+1 more)

`PROTECTED`

keyword

Specification: I.E — Declarations and Bindings

Diagnostics that name it: E1024, E6030, E6039

`PUBLIC`

keyword

Specification: I.K — Abstractions

`RECOVER`

keyword

PANIC/RECOVER (handleable defects; renamed from THROW/CATCH 2026-06-26 — old keywords now error): subclass Error, SUPER(msg); PANIC FileNotFoundError(msg, path); TRY { … } RECOVER (FileNotFoundError e) { e.message e.filename } FINALLY { … } — parens required, no as; FINALLY clause optional; multiple RECOVER matched top→bottom (subclass before superclass); catching the abstract base — RECOVER (Error e) — is rejected (E4016, catch-too-broad): name concrete subclasses, there is no catch-all. Catch as close to the problem as possible. Compiler injects filename/line/thread. Unwind runs CLEANUP. (e.message is char32[] — read it via format/auto-convert, not String methods.)

Specification: I.M — Error Handling

`REFERENCE`

keyword

=@ | non-owning reference bind; requires REFERENCE/MUTABLE REFERENCE LHS + a place expression. |

Specification: I.I — Memory and Ownership

Diagnostics that name it: E1024, E1111, E1114, E1115, E1120, E1121, E1122, E2047 (+25 more)

`REPEAT`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E1030

`RETURN`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E1119, E2052, E2053, E3022, E3029, E3030, E3031, E4001 (+10 more)

`RETURNS`

keyword

Specification: I.M — Error Handling

Diagnostics that name it: E1015, E2082, E3029, E3030, E3031, E6050, E6051, E6052 (+8 more)

`RROTATE`

keyword

Specification: I.F — Expressions

`RSHIFT`

keyword

Specification: I.F — Expressions

`SECRET`

keyword

Specification: I.I — Memory and Ownership

`SELF`

keyword

Pass minimal handles, not whole instances. An iterator takes the head node (CREATE LinkedListIterator[T](.head)), not the list — no SELF needed. (Same minimalism as bounded genericity.)

Specification: I.L — Concurrency

Diagnostics that name it: E1085, E2038, E2039, E2068, E2076, E3025, E3026, E3032 (+4 more)

`SETS_ERRNO`

keyword

Specification: I.N — Modules and Linkage

Diagnostics that name it: E2094

`SHARED`

keyword

Specification: I.E — Declarations and Bindings

Diagnostics that name it: E1024, E1080, E1115, E2115, E2116, E2117, E3032, E6010 (+2 more)

`SINGLETON`

keyword

Specification: I.B — Definitions and Notation

Diagnostics that name it: E1099, E1100, E1101, E1102, E1103

`SNAPSHOT`

keyword

`STACKTRACE`

keyword

`STEP`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E4025

`STRUCT`

keyword

Specification: I.N — Modules and Linkage

Diagnostics that name it: E2096, E6003, E6004, E6005, E6016, E6030, E6031, E6039 (+6 more)

`SUCCESS`

keyword

STATUS (recoverable): SUCCESS / PARTIAL_SUCCESS(msg[,code]) / FAILURE(msg[,code]). Assign with =. Test in plain IF: IF s IS FAILURE (no ELSE — use MATCH to bind msg/code).

Specification: I.M — Error Handling

Diagnostics that name it: E1007

`SUPER`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E4026, E6011, E6012, E6033

`SYNCHRONIZED`

keyword

Specification: I.L — Concurrency

Diagnostics that name it: E4110

`TEMPLATE`

keyword

Specification: I.K — Abstractions

Diagnostics that name it: E2110

`TEMPORARY`

keyword

`THEN`

keyword

Specification: I.M — Error Handling

Diagnostics that name it: E1090

`THROW`

keyword

Specification: I.M — Error Handling

Diagnostics that name it: E4006, E4009, E4022, W10042

`TO`

keyword

Specification: I.H — Control Flow

`TRUE`

keyword

Specification: I.D — The Type System

`TRY`

keyword

FINALLY { } is the optional trailing clause of a TRY (§13) — not standalone; runs last on every exit path of its TRY (one per TRY, no RETURN/PANIC inside).

Specification: I.M — Error Handling

Diagnostics that name it: E4016, E4017, W10013, W10042

`TYPE`

keyword

Specification: I.K — Abstractions

`TYPES`

keyword

Specification: I.C — Lexical Forms

`UNION`

keyword

Specification: I.D — The Type System

Diagnostics that name it: E6004, E6016, E6062

`UNREACHABLE`

keyword

Specification: I.H — Control Flow

`UNREACHABLE!`

keyword

`UNSAFE`

keyword

Specification: I.I — Memory and Ownership

Diagnostics that name it: E3036, E3037

`UNTIL`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: W10001, W10019

`VALID`

keyword

Specification: I.D — The Type System

Diagnostics that name it: E2080, E6041, E6042, E6043, E6044, E6045

`VALUE`

keyword

Specification: I.J — Aggregates and Iteration

Diagnostics that name it: E1132, E1133

`VERSION`

keyword

`VOID`

keyword

Specification: I.K — Abstractions

`VOLATILE`

keyword

Specification: I.E — Declarations and Bindings

Diagnostics that name it: E3008, E4102, E6032

`WHEN`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E1013, E1095, E1096, E1097, E1104, E1105, E2005, E4003 (+6 more)

`WHILE`

keyword

Specification: I.H — Control Flow

Diagnostics that name it: E1030, W10001, W10019

`WITH`

keyword

Specification: I.H — Control Flow

`XOR`

keyword

Specification: I.B — Definitions and Notation

`im`

keyword

Specification: I.C — Lexical Forms

Primitive types (31)

`C.long`

primitive · c_abi

Specification: I.D — The Type System

`C.size_t`

primitive · c_abi

Specification: I.D — The Type System

`C.ssize_t`

primitive · c_abi

Specification: I.D — The Type System

`C.unsignedLong`

primitive · c_abi

Specification: I.D — The Type System

`bigint`

primitive · arbitrary_int · reserved

Specification: I.D — The Type System

`binary`

primitive · binary · 8-bit

Specification: I.D — The Type System

Conversions: 2e.i binary — the octet (added 2026-08-28; byte retired 2026-08-29); 3. Formatting (->format) and auto-conversion — what is handled, what is not; 5. Not AS/INTO — reach for these instead — see docs/CONVERSIONS.md.

`bit`

primitive · bit · 1-bit · reserved

Specification: I.D — The Type System

`boolean`

primitive · boolean

Specification: I.D — The Type System

Conversions: 2b. Value / char → String (rendering — always lossless + total); 2c. String → value (parse — lossless but can fail); 3. Formatting (->format) and auto-conversion — what is handled, what is not — see docs/CONVERSIONS.md.

`char16`

primitive · char · 16-bit

Specification: I.D — The Type System

Also written c16.

Conversions: 2b. Value / char → String (rendering — always lossless + total); 2e. char ↔ integer (bit-twins, widening, narrowing); 2e.i binary — the octet (added 2026-08-28; byte retired 2026-08-29) — see docs/CONVERSIONS.md.

`char32`

primitive · char · 32-bit

Specification: I.D — The Type System

Also written char, character, c32.

`char8`

primitive · char · 8-bit

Specification: I.D — The Type System

Also written c8.

`complex`

primitive · complex

Specification: I.D — The Type System

Conversions: 2g. number and complex (the value-class numeric primitives, §I.D.i(g)); 2h. decimal128 (the exact base-10 primitive, §I.D.i); 4. Per-host detail (where each operator lives + edge cases) — see docs/CONVERSIONS.md.

`complex_float32`

primitive · complex_float · 32-bit · reserved

Specification: I.D — The Type System

`complex_float64`

primitive · complex_float · 64-bit · reserved

Specification: I.D — The Type System

`complex_int32`

primitive · complex_int · 32-bit · reserved

Specification: I.D — The Type System

`decimal128`

primitive · decimal · 128-bit

Specification: I.D — The Type System

Also written decimal.

Conversions: 2h. decimal128 (the exact base-10 primitive, §I.D.i); 4. Per-host detail (where each operator lives + edge cases) — see docs/CONVERSIONS.md.

`float32`

primitive · float · 32-bit

Specification: I.D — The Type System

Also written float, f32.

Conversions: 2a. Numeric ↔ numeric; 2b. Value / char → String (rendering — always lossless + total); 2c. String → value (parse — lossless but can fail) — see docs/CONVERSIONS.md.

`float64`

primitive · float · 64-bit

Specification: I.D — The Type System

Also written f64.

Conversions: 2a. Numeric ↔ numeric; 2b. Value / char → String (rendering — always lossless + total); 2c. String → value (parse — lossless but can fail) — see docs/CONVERSIONS.md.

`int128`

primitive · signed_int · 128-bit

Specification: I.D — The Type System

Also written i128.

Conversions: 2a. Numeric ↔ numeric; 2b. Value / char → String (rendering — always lossless + total); 2c. String → value (parse — lossless but can fail) — see docs/CONVERSIONS.md.

`int16`

primitive · signed_int · 16-bit

Specification: I.D — The Type System

Also written i16.

Conversions: 2a. Numeric ↔ numeric; 2e. char ↔ integer (bit-twins, widening, narrowing); 2e.i binary — the octet (added 2026-08-28; byte retired 2026-08-29) — see docs/CONVERSIONS.md.

`int32`

primitive · signed_int · 32-bit

Specification: I.D — The Type System

Also written i32.

Conversions: 2a. Numeric ↔ numeric; 2b. Value / char → String (rendering — always lossless + total); 2c. String → value (parse — lossless but can fail) — see docs/CONVERSIONS.md.

`int64`

primitive · signed_int · 64-bit

Specification: I.D — The Type System

Also written integer, int, i64.

Conversions: 2a. Numeric ↔ numeric; 2b. Value / char → String (rendering — always lossless + total); 2c. String → value (parse — lossless but can fail) — see docs/CONVERSIONS.md.

`int8`

primitive · signed_int · 8-bit

Specification: I.D — The Type System

Also written i8.

Conversions: 2a. Numeric ↔ numeric; 2e. char ↔ integer (bit-twins, widening, narrowing); 2e.i binary — the octet (added 2026-08-28; byte retired 2026-08-29) — see docs/CONVERSIONS.md.

`number`

primitive · number

Specification: I.D — The Type System

`opaque`

primitive · opaque

Specification: I.D — The Type System

Conversions: 3. Formatting (->format) and auto-conversion — what is handled, what is not — see docs/CONVERSIONS.md.

`rational`

primitive · rational · reserved

Specification: I.D — The Type System

`uint128`

primitive · unsigned_int · 128-bit

Specification: I.D — The Type System

Also written u128.

Conversions: 2a. Numeric ↔ numeric; 2b. Value / char → String (rendering — always lossless + total); 2c. String → value (parse — lossless but can fail) — see docs/CONVERSIONS.md.

`uint16`

primitive · unsigned_int · 16-bit

Specification: I.D — The Type System

Also written u16.

Conversions: 2a. Numeric ↔ numeric; 2e. char ↔ integer (bit-twins, widening, narrowing); 2e.i binary — the octet (added 2026-08-28; byte retired 2026-08-29) — see docs/CONVERSIONS.md.

`uint32`

primitive · unsigned_int · 32-bit

Specification: I.D — The Type System

Also written u32.

Conversions: 2a. Numeric ↔ numeric; 2b. Value / char → String (rendering — always lossless + total); 2c. String → value (parse — lossless but can fail) — see docs/CONVERSIONS.md.

`uint64`

primitive · unsigned_int · 64-bit

Specification: I.D — The Type System

Also written uint, u64.

Conversions: 2a. Numeric ↔ numeric; 2b. Value / char → String (rendering — always lossless + total); 2c. String → value (parse — lossless but can fail) — see docs/CONVERSIONS.md.

`uint8`

primitive · unsigned_int · 8-bit

Specification: I.D — The Type System

Also written u8.

Conversions: 2a. Numeric ↔ numeric; 2e. char ↔ integer (bit-twins, widening, narrowing); 2e.i binary — the octet (added 2026-08-28; byte retired 2026-08-29) — see docs/CONVERSIONS.md.

Types (285)

`Agg`

enum · Data

API: Data — Agg

`AggSpec`

struct · Data

API: Data — AggSpec

`Arithmetic`

interface · kernel

Specification: I.K — Abstractions

API: kernel — Arithmetic

`Array`

class · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — Array

`ArrayIterator`

class · kernel

API: kernel — ArrayIterator

`AtomicBinary`

class · kernel

API: kernel — AtomicBinary

`AtomicBoolean`

class · kernel

Specification: I.I — Memory and Ownership

API: kernel — AtomicBoolean

`AtomicChar16`

class · kernel

API: kernel — AtomicChar16

`AtomicChar32`

class · kernel

API: kernel — AtomicChar32

`AtomicChar8`

class · kernel

API: kernel — AtomicChar8

`AtomicInt16`

class · kernel

API: kernel — AtomicInt16

`AtomicInt32`

class · kernel

Specification: I.I — Memory and Ownership

API: kernel — AtomicInt32

`AtomicInt64`

class · kernel

Specification: I.L — Concurrency

API: kernel — AtomicInt64

`AtomicInt8`

class · kernel

API: kernel — AtomicInt8

`AtomicUint16`

class · kernel

API: kernel — AtomicUint16

`AtomicUint32`

class · kernel

API: kernel — AtomicUint32

`AtomicUint64`

class · kernel

API: kernel — AtomicUint64

`AtomicUint8`

class · kernel

API: kernel — AtomicUint8

`BackpressurePolicy`

enum · kernel

Specification: I.L — Concurrency

API: kernel — BackpressurePolicy

`Base64Codec`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Base64Codec

`BidirectionalIterator`

interface · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — BidirectionalIterator

`BinaryMode`

enum · kernel

API: kernel — BinaryMode

`BinaryWord`

class · kernel

API: kernel — BinaryWord

`BoolColumn`

class · Data

API: Data — BoolColumn

`Box`

class · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — Box

`Broker`

class · kernel

Specification: I.L — Concurrency

API: kernel — Broker

`Build`

enum · kernel

Specification: I.H — Control Flow

API: kernel — Build

`BuildInfo`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — BuildInfo

`BuildLedger`

class · epm

API: epm — BuildLedger

`BuildOutcome`

class · epm

API: epm — BuildOutcome

`BuildPlan`

class · epm

API: epm — BuildPlan

`BuildUnit`

class · epm

API: epm — BuildUnit

`Builder`

class · epm

API: epm — Builder

`ByteBuffer`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — ByteBuffer

`ByteBufferIterator`

class · kernel

API: kernel — ByteBufferIterator

`ByteBufferView`

class · kernel

Specification: I.D — The Type System

API: kernel — ByteBufferView

`ByteOrderCodec`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — ByteOrderCodec

`CasualRandom`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — CasualRandom

`ChainedHashDictionary`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — ChainedHashDictionary

`Channel`

class · kernel

Specification: I.L — Concurrency

API: kernel — Channel

`ChannelWriterSink`

class · Logger

API: Logger — ChannelWriterSink

`CharClassifier`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — CharClassifier

`CharConverter`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — CharConverter

`CharWidthConverter`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — CharWidthConverter

`Cloneable`

interface · kernel

Specification: I.K — Abstractions

API: kernel — Cloneable

`Codec`

class · Json

Specification: I.P — Serialization and Reconstruction

API: Json — Codec

`Collectable`

group · kernel

Specification: I.K — Abstractions

API: kernel — Collectable

`Collection`

interface · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — Collection

`Collectors`

group · kernel

API: kernel — Collectors

`CollisionNode`

class · kernel

API: kernel — CollisionNode

`Column`

class · mda

Specification: I.J — Aggregates and Iteration

API: mda — Column

`ColumnBacking`

enum · Data

API: Data — ColumnBacking

`ColumnExpr`

class · Data

API: Data — ColumnExpr

`ColumnSpec`

struct · Data

API: Data — ColumnSpec

`ColumnType`

enum · Data

API: Data — ColumnType

`Comparable`

interface · kernel

Specification: I.K — Abstractions

API: kernel — Comparable

`Compare`

enum · Data

API: Data — Compare

`CompileError`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — CompileError

`Complex`

class · kernel

Specification: I.D — The Type System

API: kernel — Complex

`ComplexConversions`

class · kernel

API: kernel — ComplexConversions

`Concurrency`

group · kernel

API: kernel — Concurrency

`Config`

class · epm

API: epm — Config

`ConsoleSink`

class · Logger

API: Logger — ConsoleSink

`Countable`

interface · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — Countable

`CsvOptions`

struct · Data

API: Data — CsvOptions

`CsvSink`

class · Data

API: Data — CsvSink

`CsvSource`

class · Data

API: Data — CsvSource

`DataError`

class · Data

API: Data — DataError

`DataFrame`

class · Data

API: Data — DataFrame

`DataKind`

enum · kernel

API: kernel — DataKind

`DataSink`

interface · Data

API: Data — DataSink

`DataSource`

interface · Data

API: Data — DataSource

`DataValue`

class · kernel

Specification: I.P — Serialization and Reconstruction

API: kernel — DataValue

`DataValueBuilder`

class · kernel

API: kernel — DataValueBuilder

`DataValueFrame`

class · kernel

API: kernel — DataValueFrame

`DataValueReader`

class · kernel

API: kernel — DataValueReader

`DateTime`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — DateTime

`DateTimeFactory`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — DateTimeFactory

`DateTimeFields`

struct · kernel

API: kernel — DateTimeFields

`Decimal128`

class · kernel

API: kernel — Decimal128

`DecimalCodec`

class · kernel

API: kernel — DecimalCodec

`DecimalColumn`

class · Data

API: Data — DecimalColumn

`DecimalConversions`

class · kernel

API: kernel — DecimalConversions

`DecimalParts`

struct · kernel

API: kernel — DecimalParts

`DecimalText`

class · kernel

API: kernel — DecimalText

`DefaultHasher`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — DefaultHasher

`Deque`

class · kernel

Specification: I.P — Serialization and Reconstruction

API: kernel — Deque

`Deserializer`

interface · kernel

Specification: I.P — Serialization and Reconstruction

API: kernel — Deserializer

`Dictionary`

interface · kernel

Specification: I.P — Serialization and Reconstruction

API: kernel — Dictionary

`DurationText`

class · kernel

API: kernel — DurationText

`DynamicByteBuffer`

class · kernel

Specification: I.F — Expressions

API: kernel — DynamicByteBuffer

`DynamicString`

class · kernel

Specification: I.D — The Type System

API: kernel — DynamicString

`Encoding`

enum · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Encoding

`Endianness`

enum · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Endianness

`EnumKind`

struct · kernel

Specification: I.K — Abstractions

API: kernel — EnumKind

`EnumReflection`

class · kernel

Specification: I.P — Serialization and Reconstruction

API: kernel — EnumReflection

`Equatable`

interface · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — Equatable

`Error`

class · kernel

Specification: I.M — Error Handling

API: kernel — Error

`ExternalDep`

struct · epm

API: epm — ExternalDep

`Externals`

class · epm

API: epm — Externals

`FastIntHasher`

class · kernel

API: kernel — FastIntHasher

`Fetcher`

class · epm

API: epm — Fetcher

`Field`

class · Logger

Specification: I.N — Modules and Linkage

API: Logger — Field

`File`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — File

`FileError`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — FileError

`FileSink`

class · Logger

API: Logger — FileSink

`FloatBigInt`

class · kernel

API: kernel — FloatBigInt

`FloatConverter`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — FloatConverter

`FloatFormat`

class · kernel

Specification: I.K — Abstractions

API: kernel — FloatFormat

`FloatParse`

class · kernel

API: kernel — FloatParse

`FloatParseConverter`

class · kernel

API: kernel — FloatParseConverter

`FloatParseResult`

class · kernel

API: kernel — FloatParseResult

`FloatToDecimal`

class · kernel

API: kernel — FloatToDecimal

`Floating`

group · kernel

Specification: I.F — Expressions

API: kernel — Floating

`FloatingDecimal32`

struct · kernel

API: kernel — FloatingDecimal32

`FloatingDecimal64`

struct · kernel

API: kernel — FloatingDecimal64

`FormatSpec`

struct · kernel

API: kernel — FormatSpec

`Formatter`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Formatter

`FrameBuilder`

class · Data

API: Data — FrameBuilder

`Future`

class · kernel

Specification: I.L — Concurrency

API: kernel — Future

`GitHubRepo`

struct · epm

API: epm — GitHubRepo

`GroupBy`

class · Data

API: Data — GroupBy

`GrowthHint`

enum · kernel

API: kernel — GrowthHint

`HashBucket`

class · kernel

API: kernel — HashBucket

`HashBucketIterator`

class · kernel

API: kernel — HashBucketIterator

`HashConstants`

class · kernel

API: kernel — HashConstants

`HashKey`

group · kernel

Specification: I.K — Abstractions

API: kernel — HashKey

`Hashable`

interface · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Hashable

`Hasher`

interface · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Hasher

`HexCodec`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — HexCodec

`HttpClient`

class · Networking

API: Networking — HttpClient

`HttpHeader`

class · Networking

API: Networking — HttpHeader

`HttpMethod`

enum · Networking

API: Networking — HttpMethod

`HttpResponse`

class · Networking

Specification: I.N — Modules and Linkage

API: Networking — HttpResponse

`IColumn`

interface · Data

API: Data — IColumn

`ICommand`

interface · epm

API: epm — ICommand

`Identity`

struct · kernel

Specification: I.K — Abstractions

API: kernel — Identity

`IndexOutOfBoundsError`

class · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — IndexOutOfBoundsError

`InlineIntHasher`

class · kernel

API: kernel — InlineIntHasher

`Inoperative`

interface · kernel

API: kernel — Inoperative

`IntKeyedDictionary`

class · kernel

API: kernel — IntKeyedDictionary

`IntKeyedDictionaryIterator`

class · kernel

API: kernel — IntKeyedDictionaryIterator

`Iso8601`

class · Data

API: Data — Iso8601

`Iterator`

interface · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — Iterator

`JoinKind`

enum · Data

API: Data — JoinKind

`JsonEncoder`

class · Logger

API: Logger — JsonEncoder

`JsonFrame`

class · Json

Specification: I.N — Modules and Linkage

API: Json — JsonFrame

`JsonParser`

class · epm

API: epm — JsonParser

`JsonReader`

class · Json

API: Json — JsonReader

`JsonValue`

class · epm

API: epm — JsonValue

`JsonWriter`

class · Json

API: Json — JsonWriter

`LinkedList`

class · kernel

Specification: I.P — Serialization and Reconstruction

API: kernel — LinkedList

`LinkedListIterator`

class · kernel

API: kernel — LinkedListIterator

`LinkedListNode`

class · kernel

API: kernel — LinkedListNode

`Lock`

class · kernel

Specification: I.K — Abstractions

API: kernel — Lock

`LockEntry`

struct · epm

API: epm — LockEntry

`LockFile`

class · epm

API: epm — LockFile

`LogEncoder`

interface · Logger

API: Logger — LogEncoder

`LogLevel`

enum · Logger

API: Logger — LogLevel

`LogRecord`

class · Logger

API: Logger — LogRecord

`LogSink`

interface · Logger

API: Logger — LogSink

`LogValue`

class · Logger

API: Logger — LogValue

`LogValueKind`

enum · Logger

API: Logger — LogValueKind

`Logger`

class · Logger

Specification: I.O — The Standard Library Surface

API: Logger — Logger

`Main`

class · epm

Specification: I.N — Modules and Linkage

API: epm — Main

`Manifest`

class · epm

API: epm — Manifest

`Math`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Math

`MathError`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — MathError

`Mda`

class · mda

API: mda — Mda

`MdaError`

class · mda

API: mda — MdaError

`MeasuringTimer`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — MeasuringTimer

`ModuleWorker`

class · epm

API: epm — ModuleWorker

`MultiplexSink`

class · Logger

API: Logger — MultiplexSink

`Multiplier`

interface · kernel

Specification: I.F — Expressions

API: kernel — Multiplier

`Mutex`

class · kernel

Specification: I.L — Concurrency

API: kernel — Mutex

`NativeDep`

struct · epm

API: epm — NativeDep

`NetworkError`

class · Networking

Specification: I.O — The Standard Library Surface

API: Networking — NetworkError

`NullPointerException`

class · kernel

Specification: I.I — Memory and Ownership

API: kernel — NullPointerException

`NullSink`

class · Logger

API: Logger — NullSink

`NumStore`

union · kernel

Specification: I.D — The Type System

API: kernel — NumStore

`Number`

class · kernel

Specification: I.D — The Type System

API: kernel — Number

`NumberColumn`

class · Data

API: Data — NumberColumn

`NumberConversions`

class · kernel

API: kernel — NumberConversions

`NumberConverter`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — NumberConverter

`NumberKind`

enum · kernel

Specification: I.D — The Type System

API: kernel — NumberKind

`NumberToDecimal`

class · kernel

API: kernel — NumberToDecimal

`Numeric`

group · kernel

Specification: I.K — Abstractions

API: kernel — Numeric

`NumericLimits`

class · kernel

Specification: I.K — Abstractions

API: kernel — NumericLimits

`NumericUtilities`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — NumericUtilities

`ObjectIterator`

interface · kernel

API: kernel — ObjectIterator

`OrderedArray`

class · kernel

API: kernel — OrderedArray

`OwnedList`

class · kernel

Specification: I.K — Abstractions

API: kernel — OwnedList

`OwnedListIterator`

class · kernel

API: kernel — OwnedListIterator

`OwnedListNode`

class · kernel

API: kernel — OwnedListNode

`PackageRef`

struct · epm

API: epm — PackageRef

`PartialSpec`

struct · epm

API: epm — PartialSpec

`Path`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Path

`PoolSlot`

class · Networking

API: Networking — PoolSlot

`Pow5Entry`

struct · kernel

API: kernel — Pow5Entry

`PrimitiveConversions`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — PrimitiveConversions

`Printable`

interface · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Printable

`ProHashDictionary`

class · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — ProHashDictionary

`ProHashDictionaryIterator`

class · kernel

API: kernel — ProHashDictionaryIterator

`Process`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Process

`ProcessResult`

struct · kernel

Specification: I.O — The Standard Library Surface

API: kernel — ProcessResult

`Queue`

class · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — Queue

`RBNode`

class · kernel

API: kernel — RBNode

`Random`

interface · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Random

`RandomError`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — RandomError

`RawThread`

class · kernel

API: kernel — RawThread

`Readable`

interface · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Readable

`RedBlackTreeDictionary`

class · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — RedBlackTreeDictionary

`RedBlackTreeDictionaryIterator`

class · kernel

API: kernel — RedBlackTreeDictionaryIterator

`ReferenceIterator`

interface · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — ReferenceIterator

`Regex`

class · Regex

Specification: I.D — The Type System

API: Regex — Regex

`Resolution`

struct · epm

Specification: I.N — Modules and Linkage

API: epm — Resolution

`ResolvedDep`

struct · epm

API: epm — ResolvedDep

`Resolver`

class · epm

API: epm — Resolver

`ResponseReader`

class · Networking

API: Networking — ResponseReader

`RetryPolicy`

class · Networking

API: Networking — RetryPolicy

`RoundingMode`

enum · kernel

API: kernel — RoundingMode

`Row`

class · Data

Specification: I.N — Modules and Linkage

API: Data — Row

`RowIterator`

class · Data

API: Data — RowIterator

`Searchable`

interface · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — Searchable

`SecureRandom`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — SecureRandom

`SeededRandom`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — SeededRandom

`SemVersion`

struct · epm

API: epm — SemVersion

`Semver`

class · epm

API: epm — Semver

`Serializable`

interface · kernel

Specification: I.P — Serialization and Reconstruction

API: kernel — Serializable

`Serializer`

interface · kernel

Specification: I.P — Serialization and Reconstruction

API: kernel — Serializer

`Set`

class · kernel

Specification: I.N — Modules and Linkage

API: kernel — Set

`Severity`

enum · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Severity

`ShallowDictionary`

class · kernel

API: kernel — ShallowDictionary

`ShallowDictionaryIterator`

class · kernel

API: kernel — ShallowDictionaryIterator

`Shareable`

interface · kernel

Specification: I.K — Abstractions

API: kernel — Shareable

`Shuffleable`

interface · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Shuffleable

`Shuffler`

interface · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Shuffler

`SipHasher`

class · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — SipHasher

`SipState`

class · kernel

API: kernel — SipState

`SipVariant`

enum · kernel

API: kernel — SipVariant

`Socket`

class · Networking

Specification: I.N — Modules and Linkage

API: Networking — Socket

`SortedList`

class · kernel

Specification: I.P — Serialization and Reconstruction

API: kernel — SortedList

`Stack`

class · kernel

Specification: I.M — Error Handling

API: kernel — Stack

`Stdio`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Stdio

`String`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — String

`StringHasher`

class · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — StringHasher

`StringIterator`

class · kernel

API: kernel — StringIterator

`StringKeyedDictionary`

class · kernel

API: kernel — StringKeyedDictionary

`StringKeyedDictionaryIterator`

class · kernel

API: kernel — StringKeyedDictionaryIterator

`StringView`

class · kernel

Specification: I.D — The Type System

API: kernel — StringView

`Subscription`

class · kernel

Specification: I.I — Memory and Ownership

API: kernel — Subscription

`System`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — System

`TLSSocket`

class · Networking

API: Networking — TLSSocket

`Tag`

struct · epm

Specification: I.D — The Type System

API: epm — Tag

`Task`

class · kernel

Specification: I.L — Concurrency

API: kernel — Task

`TaskStarter`

interface · kernel

Specification: I.N — Modules and Linkage

API: kernel — TaskStarter

`TemporalColumn`

class · Data

API: Data — TemporalColumn

`TemporalKind`

enum · Data

API: Data — TemporalKind

`TestRunner`

class · evTest

API: evTest — TestRunner

`Text`

group · kernel

Specification: I.D — The Type System

API: kernel — Text

`TextColumn`

class · Data

Specification: I.N — Modules and Linkage

API: Data — TextColumn

`TextConverter`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — TextConverter

`TextEncoder`

class · Logger

API: Logger — TextEncoder

`ThreadCondition`

class · kernel

Specification: I.I — Memory and Ownership

API: kernel — ThreadCondition

`TimeComparison`

enum · kernel

Specification: I.O — The Standard Library Surface

API: kernel — TimeComparison

`TimeConstants`

class · kernel

API: kernel — TimeConstants

`TimeDuration`

class · kernel

Specification: I.P — Serialization and Reconstruction

API: kernel — TimeDuration

`TlsError`

class · Networking

API: Networking — TlsError

`Toolchain`

class · epm

API: epm — Toolchain

`UTFCodec`

class · kernel

Specification: I.D — The Type System

API: kernel — UTFCodec

`UrlCodec`

class · Networking

API: Networking — UrlCodec

`ValueIterator`

interface · kernel

Specification: I.J — Aggregates and Iteration

API: kernel — ValueIterator

`ValuePrimitive`

group · kernel

API: kernel — ValuePrimitive

`VersionRange`

struct · epm

API: epm — VersionRange

`View`

interface · kernel

Specification: I.K — Abstractions

API: kernel — View

`Viewable`

interface · kernel

API: kernel — Viewable

`WordKey`

group · kernel

Specification: I.K — Abstractions

API: kernel — WordKey

`WorkerBody`

class · kernel

API: kernel — WorkerBody

`WorkerJobNode`

class · kernel

API: kernel — WorkerJobNode

`WorkerPool`

class · kernel

Specification: I.L — Concurrency

API: kernel — WorkerPool

`WorkerPoolCore`

class · kernel

API: kernel — WorkerPoolCore

`Workspace`

class · epm

API: epm — Workspace

`Writable`

interface · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Writable

`Xoshiro256`

class · kernel

Specification: I.O — The Standard Library Surface

API: kernel — Xoshiro256

`opaque`

primitive · kernel

Specification: I.I — Memory and Ownership

API: kernel — opaque