stories/foundations.md |
spec/foundations.md — the bets behind captured intent, staged compilation, casing-determines-kind, strictness-as-performance, and the collapse of value/reference into one # axis |
stories/lexical.md |
spec/lexical.md — casing as a hard-error kind signal and the <> disambiguation it buys, why field privacy lives in the name and reaches across packages, and a delimiter for each kind of separated thing |
stories/types.md |
spec/types.md — the two-axis value/reference model, why # marks a distinct type rather than a box, constructing a type by what it is, confining # to the body forms, why every user-defined type must be named, dropping the tuple mould once a named struct does the job better, adding named constructors, naming the enum's shape the peer mould, and making Unit a real fundamental unit type |
stories/adt.md |
spec/adt.md — splitting enum from variant against the hype, the shared struct body, escaping the matcher machine with case overloads and the turn to a central match block, matching variants rather than patterns, keeping enum data outside the members, reducing a match group to sugar for one arm per case, building a variant by naming a case rather than calling a constructor, the bindings that existed only to be pointed at, and making a recursive member an owned child boxed through a hosting handle rather than an &, and the sum that could not contain itself until a value copy became deep |
stories/generics.md |
spec/generics.md — the parameter model, the <>/() split, size-in-the-type, and the deferred features |
stories/dependencies.md |
spec/dependencies.md — URL identity, the manifest/resolution split, prebuilt distribution, symbol-rewriting, the browsable global cache, the package-graph acyclicity rule, opt-in remapping, and why core became a bundled implementation package |
stories/memory.md |
spec/memory.md — the no-GC-no-lifetimes goal, the move problem and the anchor, lazy backpointer creation, the indexed heap table, the rooted-guest rules and the host/guest terminology split, the collapse to one value/reference axis with a borrowed subject, the shift to segmented chunked bump arenas, the split into fixed-size and dynamic regions with anchors moved to a runtime-global recyclable pool, taking the bare symbol away as a guest source, the three passing modes that split out of it, and the dynamic region taking the boxes, each asking for exactly its own size, once recursion became hosting, and what a copy is for — the deep value copy that lets a value type recurse, and the reference-field ban that survived it |
stories/lifetimes.md |
spec/lifetimes.md — lexical scope in place of a borrow checker, what may be moved, the declaration-block rule that kills flow analysis, downgrade instead of use-after-move, parameter-rooted returned guests, why each strict rule is the minimal guard against one specific memory corruption, and narrowing a returned guest's root to a guest parameter once borrows arrived |
stories/effects.md |
spec/effects.md — inferring effects instead of annotating them, subject-scoped mut, capabilities in place of ambient I/O, the four-level ladder and the Total-Pure/Pure split, what deliberately is not an effect, and mutation through a borrowed subject |
stories/concurrency.md |
spec/concurrency.md — the parallelism/concurrency split and the refusal of async coloring, why spawn marks only a call, water-tower lifetimes, signature-based safety without locks, and value-typed mutation closing the aliased-write gap |
stories/error-handling.md |
spec/error-handling.md — the two-doors model and why failure is control flow rather than a Result value, resolve as expression-substitution rather than assignment, typed abort paths and the deliberately-absent propagate operator, keeping abortability orthogonal to effects, and explicit path values through Unit |
stories/control-flow.md |
spec/control-flow.md — guard as an active exit that opens no scope of its own, doing without while behind a written loop bound, one-based counting after the loop that forced the question, and why control-flow contracts use fundamental semantic types |
stories/functions.md |
spec/functions.md — pulling methods out of the type body and the verb model that revealed, mutation made visible with :/!, overloading on parameter shape alone, why callables are call-only while self-typed lambdas are values, why every return carries an explicit value, and dropping the inherited word "receiver" for subject |
stories/operators.md |
spec/operators.md — the fixed vocabulary worth overloading, ~ as the universal flip, laws enforced through derived operators, grammar-only grouping, and home-package coherence |
stories/packages.md |
spec/packages.md — the directory as namespace and compilation unit, declarations as move checks, explicit qualified access through $, and keeping mutable state inside values so the effect model can see it |