The address of a value is its content.
Yon allocates into xleech2, a content-addressed heap. Allocation hashes the bytes; identical content returns the existing slot, and a hash collision is settled by a direct byte comparison, so distinct content never aliases and same content ⇔ same slot. Equality of arbitrarily large values is then one integer comparison: O(1) structural equality, by construction. The work is done by content-addressing, not by lattice geometry. The Leech lattice enters as a deliberate bound: a single heap addresses 196,560 contents, the count of minimal vectors of Λ24, and chains into a successor heap when it fills rather than degrading silently. Where the lattice is actually load-bearing is in the structures below (sets and error correction) and in the Arena, whose Co0/M24 orbit operations recognize contents equal up to the lattice's symmetry group.
fun main(): number { be greeting holds "ciao, mondo" // interned on the heap be _ holds String.print(greeting) return 0 }
Every string literal is a section of the builtin String place, interned on that same heap, so two equal strings are one slot, however they were built.
An XSet is a fixed-size lattice bitmap.
An XSet is a subset of the 196,560 minimal vectors of the Leech lattice, stored as a fixed 196,560-bit bitmap: 3,072 64-bit words, about 24 KB, the same size whether the set holds one element or all of them. Membership is one bit test, O(1). Union and intersection are a bitwise OR and AND over those 3,072 words, a fixed pass independent of how many elements each set holds; size is a popcount. A minimal perfect hash places each minimal vector at its bit with no table of its own and zero collisions, verified exhaustively over all 196,560 (runtime/test_mphf.c).
A general-purpose hash set matches the O(1) membership, but not the constant-time set algebra: there, union and intersection cost time proportional to the sets. Here they are a fixed 3,072-word pass with no per-element work.
The list type stores error-correcting codewords.
A VoyagerList stores each 12-bit payload as a 24-bit codeword of the binary Golay code (24, 12, 8), the code the Voyager probes used to send images home across the solar system. Encoding and syndrome decoding run through the real mmgroup mat24 tables, not a re-implementation. The code has minimum distance 8, so any three flipped bits in a codeword are detected and corrected on read. The Golay code is not decoration here: it is the combinatorial object the Leech lattice is built from, so the same engine that addresses sets also hardens storage against corruption.
Worlds are categories, behaviour is arrows.
In Topos-Oriented Programming a world is a category, a place is an object in it, and a value is a section: immutable, identified by its content. All behaviour lives in arrows. Identity is the exception, requested only where you need it. Logic is internal: truth is the subobject classifier Ω, and unknown is a citizen of the Heyting core, not an error. From the Yoneda lemma, a thing is determined by its relations; the type checker, optimizer, and allocator act on that.
An arrow carries only what its type says.
A morphism (a move, a view, a reduction) is closed: its body may use its own parameters and top-level definitions, and nothing else. Capturing a local from the surrounding scope is a compile-time error, not a runtime surprise. The reason is the border: an arrow is bound, composed, and applied elsewhere, possibly on the far side of a Space boundary, in another address space, where a captured local would have nothing to point at. So the only thing that crosses between Spaces is a closed arrow applied to transported data. A plain fun is the opposite by design: a value combinator captures freely, at any nesting depth, because it lives and dies on the spot.
No garbage collector, no threads, no exceptions.
Identity is requested explicitly, the unit of concurrency is the process, failure is represented as data rather than a thrown stack, and a place's interface is its arrows. Four mechanisms common elsewhere are absent by design:
No garbage collector
Slots are stable for the life of the process; the heap grows with distinct content only.
No threads
The unit of concurrency is the process. Spaces talk over a shared-memory wire.
No exceptions
Failure is data: a place, a declaration, or a process exit, never a thrown stack.
No typeclasses
Arrows are the interface: a place’s presheaf of observations.
The editor and the compiler share one implementation.
A language server, a linter, and a formatter ship with the toolchain, and each shares its code with the command line: the editor runs the same project checker as yonc, the same rules as yon-lint, the same formatter as yon-fmt. So they cannot disagree, the editor never accepts a project the compiler rejects. Diagnostics carry stable codes read off the communication graph, the kind a single-file view cannot give: an illegal drop is E3001, a wire that crosses a world boundary is E3010. The formatter re-parses its own output and leaves the file untouched unless it can prove the meaning was preserved.