// No annotations — you still get all of this for free:
f process(data: [N], label: S): Stats
    total = data.reduce((acc, val) => acc + val, 0.0)
    r => { total, mean: total / data.length, label }

// ✅ No heap allocation       (-R default)
// ✅ No null dereference       (-N default)
// ✅ No data race              (-R: nothing shared)
// ✅ No ARC cost               (-R: no refcount)
// ✅ Zero-copy return          (r.field = DPS)
// ✅ Bounds-safe iteration     (.x() / .reduce())

// No annotations — local, immutable, non-null, zero cost
f main()
    greeting = "Hello, world!"    // S -R -M -N — inferred
    console.log(greeting)

// greeting is:  local (no heap),  immutable (no lock),  non-null (no check)
// The compiler emits zero allocation, zero null check, zero ARC operation.

// Single-line — to end of line

/* Block — spans lines */

/* Nesting works — unlike C
   /* inner comment */
   still commented out here
*/

/* Comment out any block safely, even if it has block comments inside:
    f oldVersion(data: [I])  /* deprecated */
        process(data)
*/

f add(a: I, b: I): I  // inline is fine too
    r => a + b

count  = 42          // I  inferred
small: I32 = -7     // I32 explicit width
ratio  = 3.14        // N  float64
price  = 9.99d       // D  exact decimal, no float rounding
msg    = "Hello!"    // S  UTF-8 string
alive  = true        // L  boolean
nothing: I+N = none // nullable integer — requires +N annotation

// Ranges — produce iterable values
exclusive = 0..10     // [0,10) — 0,1,2,...,9
inclusive = 1..=5    // [1,5]  — 1,2,3,4,5

email = RegExp("[a-z]+@[a-z]+\.[a-z]+", "i")  // compiled at build time
match = email.match(input)                        // returns [S]+N
clean = RegExp("\s+").replace(text, " ")

// Shorthand: variable name used as key
host = "localhost"
port = 8080
config = Config({ host, port })        // Config({ host: host, port: port })

// Spread + override: ... spreads all fields, then overrides
newConfig = Config({ ...config, host: "newhost" })
newMap    = { ...meta, "version": 4 }                // map spread

// Works in any expression context
servers = configs.map((cfg) => Server({ ...cfg, active: true }))

// Inferred — all default to -R -M -N
count    = 0              // I  -R +M -N  (local mutable, class default)
ratio    = 3.14           // N  -R -M -N
greeting = "hello"       // S  -R -M -N
point    = { x: 1.0, y: 2.0 }  // {x:N,y:N} -R +M -N
items    = [1, 2, 3]      // [I] -R +M -N

// Explicit — override inferred type or modifiers
shared: I+R+M   = 0     // shared mutable integer on heap
config: Config+R-M = load() // shared immutable Config
maybe:  User+N    = none // nullable User
width:  I32        = 640  // explicit 32-bit width

// Grouping across newlines — continues until )
total = (
    subtotal
    + tax
    + shipping
)

// Block expression — multiple statements, last is value
result = (
    step1 = doFirstThing()
    step2 = doSecondThing(step1)
    step1 + step2       // ← value of the block
)

// Complex condition spread across lines
valid = (
    user.age >= 18 &
    user.verified &
    !user.banned
)

// Argument list — newlines freely between args
response = submitOrder(
    orderId,
    items.x((i) => i.c(+R)),
    shipping.address,
    payment.token
)

// Pipeline of operations that would be awkward inline
processed = (
    raw  = a fetch(url)
    clean = sanitize(raw)
    valid = validate(clean)
    valid               // ← returned value
)

// Chained method calls broken across lines
summary = (
    orders
        .x((order) => order.paid)
        .x((order) => order.amount)
        .reduce((acc, amt) => acc + amt, 0.0)
)

// Ternary branches using () for multi-line without indentation rules
label = count > 0
? (
    plural = count > 1
    plural ? "{count} items" ! "1 item"
)
! "empty"

// Named function
f add(left: I, right: I): I
    r => left + right

// Short form — expression body
f square(val: N) = val * val

// Lambda — => implies anonymous, no f needed
double    = val => val * 2
increment = val => val + 1

// Multi-expression lambda — last expression is the return value
clean = item => (
    trimmed = item.trim()
    trimmed.lowercase()   // returned
)

// Return-by-construction — r.field writes into caller's pre-allocated slot
// No copy on return. Destination-passing style, guaranteed by the type system.
f buildUser(name: S, age: I): User
    r.name = name    // writes directly to caller's frame
    r.age  = age     // no copy occurs at return

// Default parameters
f connect(host: S, port: I = 8080): Connection+R+M+N
    r => tcp.dial(host, port)

// Higher-order — F(I):S means "function taking I, returning S"
f applyTwice(fn: F(I):I, val: I): I
    r => fn(fn(val))

result = applyTwice(double, 3)  // 12

// {} at end — optional named params with defaults
f fetch(url: S, count: I, { timeout: I = 30, verbose: L = false })

fetch("api.com", 5)                           // all defaults
fetch("api.com", 5, { verbose: true })         // one override
fetch("api.com", 5, { timeout: 60, verbose: true }) // two overrides

// Adding new optional never breaks callers:
// f fetch(url: S, count: I, { timeout: I = 30, verbose: L = false, retries: I = 3 })
// All existing call sites still work unchanged

// {} in middle? Use a named class instead:
d FetchOpts { timeout: I = 30 }
f weirdFunc(x: I, opts: FetchOpts, y: S)     // explicit, named
weirdFunc(5, FetchOpts({ timeout: 60 }), "hi")

// ❌ No defaults on positional params — compile error:
// f bad(x: I, y: I = 5)  ← banned

d Config
    host: S  = "localhost"
    port: I  = 8080
    debug: L = false

cfg  = Config({})                           // all defaults
prod = Config({ host: "prod.api.com", port: 443 })

// __construct overrides auto-generated init:
d Cache
    maxSize: I
    items: {S: S}+M = {}  // typed map

    f __construct({ maxSize: I = 100 })
        validate(t.maxSize > 0)             // custom logic
        // (Cache has no parent — parent calls only apply when extending a class)

// Array iteration: (value, index) passed, handler takes only value
nums = [10, 20, 30]
nums.x((n: I) => print(n.toString()))     // index silently dropped
nums.x((n: I, i: I) => print(i.toString() + ": " + n.toString()))  // both

// Map iteration: (value, key) passed
scores: {S: N} = { "alice": 9.8, "bob": 7.4 }
scores.x((score: N) => process(score))         // key silently dropped
scores.x((score: N, name: S) => print(name))  // both — note value comes first

// Named functions also obey the rule when used as handlers:
f process(item: S): L   r => item.length > 0
items.filter(process)   // (S, I) passed, process takes (S) — I dropped

// Compile error — declared param type must match what's supplied:
// scores.x((score: I) => ...)  ← ✗ N supplied, I declared

// Named f — hoisted, t is explicit, not captured
f greet(name: S): S
    r => "Hello, " + name

greet("Alice")   // fine even before the f declaration above (hoisted)

// Arrow function — anonymous, captures t, is a value
greet: (S)->S = (name) => "Hello, " + name

// Multi-line arrow uses () block — last expr is the value
process: (I)->S = (num) => (
    doubled = num * 2
    "result: {doubled}"
)

// Closure — captures outer variable, subject to modifier rules
f makeMultiplier(factor: I): (I)->I
    r => (num: I) => num * factor    // captures factor (I is -R, value-copied in)

double = makeMultiplier(2)    // double: (I)->I
double(5)                     // 10

// Capture rules — same modifier rules as any variable
f setup()
    local: S = "hello"                // -R stack
    msg: S+R = local.c(+R)          // heap copy

    ok: (()->())+F-R = () => log(local)    // ✅ non-escaping, in-scope only
    bad: (()->())+F+R = () => log(local)   // ❌ ERROR: +F +R captures -R local
    fine: (()->())+F+R = () => log(msg)    // ✅ +R captured into +F +R

// In a class: arrow captures t, f() does not
d Button
    clicks: I+M = 0

    f onClick()                    // t is explicit — this is a method call
        t.clicks = t.clicks + 1

    handler: (ClickEvent)->() = (e) =>  // arrow captures t from Button instance
        t.clicks = t.clicks + 1        // ✅ t is the Button

// Function values carry all modifiers like any other value
policy: (NetworkError)->()+R = (err) => retry(err)   // heap, shareable
policies: [(NetworkError)->()] = [logToSentry, retryOnRecoverable]  // array

// Passed to e.x() as a policy array — order defined, preserved
e.x(policies)

// f — named function          d — class definition
d Stack
    items: [Any]+R+M
    f push(stack: Stack+R+M, item: Any)
        t.items.append(item)      // t — self/this
    f pop(stack: Stack+R+M): Any
        t.items.isEmpty() & e StackUnderflow()  // e — throw error
        r => t.items.removeLast()  // r — return

// w — generator loop     y — yield     b — break     c — continue
f evens(): I
    num = 0
    w+I                    // w+I = intentionally infinite
        num % 2 != 0 & c  // c — skip odd numbers
        y num              // y — yield even number
        num = num + 1

// a — async function and suspension operator
a fetchUser(id: I): User+N
    r => a db.find(id)     // 'a' here = suspend (like await)

// none — the null value (multi-letter literal)
maybeUser: User+N = none

// -R -M -N default: stack, immutable, non-null — zero cost
f process(user: User, count: I): S   // all -R -M -N
    r => "done"

// +N nullable — result may be none
f findUser(id: I): User+N   // +N: may return none
    r => db.find(id)

// +R -M shared immutable — safe to broadcast, no lock needed
config: Config+R-M = loadConfig()
workers.x(worker => worker.configure(config))  // zero-copy broadcast

// +R +M shared mutable — proxy-mediated writes
cache: Cache+R+M = Cache() +M(MVCC)
cache.set(key, val)   // routed through MVCC proxy

// +V: vectorized execution (SIMD on CPU, warps on GPU)
simdVec: [N32]+V = loadData()                  // CPU SIMD — data stays on CPU
gpuVec:  [N32]+R(GPU) = simdVec.c(+R(GPU))   // copy to GPU device memory
runKernel(gpuVec)                                 // dispatches as GPU warps

// same matrix type, different location — same API
weights: [[N32]]               = loadModel()   // CPU scalar
weights: [[N32]]+V            = loadModel()   // CPU SIMD
weights: [[N32]]+R(GPU)       = loadModel()   // GPU device memory
weights: [[N32]]+R(Network)   = loadModel()   // remote cluster

// +A survives fiber suspension
a handle(): Response
    buf: [L]           = alloc(4096)  // -A: stack-local, NOT saved at suspension
    state: Req+R+A   = buildReq()   // +A: saved to fiber frame
    result = a net.get(state)          // suspend — only state saved, not buf
    r => parse(result, state)

o Math.Linear              // qualified: Linear.matmul, Linear.Foo available
o Math.Linear.*            // glob: matmul, Foo available as bare names
o Math.Linear (            // scoped qualified: only inside this block
    result = Linear.matmul(a, b)
)                          // Linear no longer in scope here
o Math.Linear.* (          // scoped glob: only inside this block
    result = matmul(a, b)  // bare name works here
)                          // matmul no longer in scope here

// file: math/linear.u

f _helper(a: [N32+V], b: [N32+V]): N  // _ prefix → private, never exported
    a.reduce((acc, i, v) => acc + v * b[i], 0.0)

o Math.Linear => (

    d Result              // becomes Math.Linear.Result
        value: [[N32+V]]
        error: N

    f matmul(a: [[N32+V]], b: [[N32+V]]): [[N32+V]]  // t absent → +G inferred
        r => a.x((i, row) => row.x((j, _) => _helper(row, b.col(j))))

    f scale(factor: N): [[N32+V]]              // t used below → instance method
        r => t.x((i, row) => row.x((j, v) => v * factor))

)

o Geometry => (
    d Circle
        radius: N

    f unitCircle(): Circle         // no t → +G, called as Geometry.unitCircle()
        r => Circle({ radius: 1.0 })

    f area(): N                     // t used → instance method
        r => Math.PI * t.radius ^ 2

    f scale(factor: N): Circle     // t used → instance method
        r => Circle({ radius: t.radius * factor })
)

// static callable on instance as sugar:
c = Geometry.unitCircle()         // direct
c = someCircle.unitCircle()       // also valid — desugars to above

// math/linear_basic.u
o Math.Linear => ( f matmul(...) )

// math/linear_advanced.u — extends same namespace
o Math.Linear => ( f svd(...)  f lu(...) )

// conflict (same function name in two files) = compile error

o "github.com/u-lang/math"   // external — resolved by package manager
o "./utils"                  // relative — exposes utils/*.u namespaces

// ── Bare +F: heterogeneous callables, homogeneous output ──────
hooks: [Config+F] = []        // any callable producing Config
hooks.append(loadFromFile)       // Config +F(path: S)
hooks.append(loadFromEnv)        // Config +F()
hooks.append(loadWithDefault(b)) // Config +F() +R (closure)
// compiler: every result is Config — enforces modifiers on output
configs: [Config] = hooks.x(hook => hook(...))

// ── +F(): explicit nullary ────────────────────────────────────
thunk: Config+F() = () => Config.default()
cfg = thunk()                    // called with zero args

// ── +F(S): fully typed ───────────────────────────────────────
parser: Config+F(S) = parseConfig  // takes S, returns Config
cfg = parser(rawJson)

// ── Composing with other modifiers (commutative) ─────────────
handler: Config+F(S)+R          // escaping closure
fetcher: Config+F(S)+A          // async function
maybe:   Config+F(S)+N          // nullable reference
escAsync: Config+F(S)+R+A     // escaping async closure

// Order is irrelevant — all identical:
Config+F+R+A == Config+A+R+F == Config+R+A+F  // same type

d Server
    f getHandler(server: Server+R): Response+F(Request)+R
        r => req => t.handleRequest(req)   // captures t — needs +R

handler: Response+F(Request)+R = server.getHandler()
route.register(path, handler)       // stored in routing table, survives

// Plugin system: all plugins produce S, inputs vary
d PluginRegistry
    plugins: Map   // keyed by name

    f register(registry: PluginRegistry+R+M, name: S, plugin: S+F)
        t.plugins[name] = plugin   // S +F: any callable producing S

    f run(registry: PluginRegistry, name: S): S+N
        plugin: S+F+N = t.plugins[name]
        r => plugin & plugin(...)   // null-guard + call
// Compiler: result is S, handling enforced regardless of plugin internals

// Basic class
d Point
    x: N
    y: N
    f distance(other: Point): N
        dx = t.x - other.x       // t = self
        dy = t.y - other.y
        r => (dx*dx + dy*dy).sqrt()

// Inheritance — : introduces base class, no multiple inheritance
d Animal
    name: S
    f speak(): S
        r => "..."

d Dog : Animal           // Dog inherits from Animal
    breed: S
    f speak(): S
        r => "Woof"          // override

// +P — policy modifier, class-level default
// all +R +M instances of Counter are Actor-mediated by default
d Counter+M(Actor)
    value: I
    f increment(t: Counter+R+M)
        t.value = t.value + 1

// Caller: no a needed — fiber handles Actor dispatch transparently
counter: Counter+R+M = Counter()
counter.increment()    // enqueued and serialized by Actor policy

// Binding-site override — same class, different policy
c2: Counter+R+M+M(MVCC) = Counter()   // override to MVCC

// Policy + inheritance combined
d LiveCounter+M(Actor) : Counter
    lastUpdated: S

// Inline nested structs — -R means value-embedded, copies recursively
d Vec2                       // small value type, always -R by default
    x: N
    y: N

d Material+R(RAII)         // GPU resource — always lives on heap
    shader: S
    f drop(t: Material+R)    // called automatically when last ref drops
        gpu.release(t.shader)

d Mesh
    origin:   Vec2             // -R inline: Vec2 embedded, copies by value
    count:    I                // -R inline: scalar, copies by value
    vertices: [Vec2]+R      // +R heap array — reference shared on .c()
    normals:  [Vec2]+R      // +R heap array — reference shared on .c()
    material: Material+R    // +R heap object — reference shared on .c()

a = Mesh{ origin: Vec2{ x: 0.0, y: 0.0 }, count: 3,
          vertices: [...], normals: [...],
          material: Material("pbr") }
b = a.c()

// b.origin   → new Vec2 (inline — x and y duplicated)
// b.count    → 3 (scalar copy)
// b.vertices → same heap array as a.vertices (reference shared)
// b.normals  → same heap array as a.normals  (reference shared)
// b.material → same Material as a.material   (RAII refcount++)

b.origin.x = 1.0    // OK — b.origin is its own copy
a.origin.x           // still 0.0 — unaffected

// Want independent vertices? Copy the array explicitly:
b.vertices = a.vertices.c()   // b now has its own vertex buffer

// +R on a local binding: heap-allocated, shareable via +R properties
mat: Material+R = Material("wireframe") // heap, refcount=1
c: Mesh+R+M = Mesh(...)
c.material = mat    // OK: mat is +R — can be shared, refcount→2

// +R cannot reference a plain -R stack var — no refcount, compile error
plain: Vec2 = Vec2{ x: 1.0, y: 2.0 }  // -R stack
c.material = plain   // ❌ types differ: +R expected, -R given

d Bar
    name: S
    f __construct(a: I)
        t.name = a.toString()
    f greet(): S                    // instance — t used
        r => "Hello from " + t.name
    f version(): S                  // static — no t
        r => "Bar v1"

d Foo : Bar
    x: S = "default"

    f __construct(a: I, b: S)
        Bar.__construct(a)            // explicit — t passed implicitly
        t.x = b                       // own init after parent

    f greet(): S                    // overrides instance method
        base = Bar.greet()           // call parent — t implicit
        r => base + ", also " + t.x

    f version(): S                  // overrides static — no t here either
        r => Bar.version() + "-Foo"

// Not calling Bar.__construct is valid — deliberate choice
// Compiler warns if __construct never calls parent's

// Define a base type and its variants
d Color
d Color.Red   : Color    // zero-field → auto-singleton
d Color.Green : Color
d Color.Blue  : Color

// Color.Red IS the value — no () needed
bg: Color = Color.Red
bg : Color.Red    // L true — isinstance
bg : Color        // L true — base type

// Variants can carry data (unlike traditional enums)
d Shape
d Shape.Circle    : Shape  { radius: N }
d Shape.Rect      : Shape  { width: N, height: N }
d Shape.Triangle  : Shape  { base: N, height: N }

// Dispatch via : type test
area = shape : Shape.Circle
? Math.PI * shape.radius ^ 2
! shape : Shape.Rect
? shape.width * shape.height
! shape.base * shape.height / 2

// Hierarchical namespaces
d NetworkError
d NetworkError.Transport         : NetworkError
d NetworkError.Transport.Timeout : NetworkError.Transport
d NetworkError.Transport.Refused : NetworkError.Transport
d NetworkError.Protocol          : NetworkError
d NetworkError.Protocol.SSL      : NetworkError.Protocol

// ❌ closed dispatch — every new Shape breaks this
area = shape : Shape.Circle   ? Math.PI * shape.radius ^ 2
     ! shape : Shape.Rect     ? shape.width * shape.height
     !                           0.0   // ← new shapes silently return 0

// ✅ open dispatch — new Shape? add one handler, no existing code changes
renderer.x((s: Shape.Circle)   => drawCircle(s.radius))
renderer.x((s: Shape.Rect)     => drawRect(s.width, s.height))
renderer.x((s: Shape.Triangle) => drawTriangle(s.base, s.height))
// add Shape.Hexagon later? one new line, zero regressions

// Same pattern already used for errors:
e.x((err: NetworkError.Transport.Timeout) => retry())
e.x((err: NetworkError.Protocol.SSL)       => alertSecurity())
// errors and enums are the same pattern. one mechanism.

d Config
    apiUrl:  S +G    = "https://api.example.com"  // static constant
    timeout: I +G    = 30                        // static constant
    calls:   I +G+M  = 0                         // static mutable counter
    host:    S       = "localhost"               // instance field (no +G)

// Pure interface — all methods abstract
d Drawable!
    f draw(ctx: Context)        // abstract — no body
    f bounds(): Rect            // abstract — no body

// Partial abstract class — some concrete, some abstract
d Animal
    f speak()!                   // abstract — subclass must implement
    f breathe()                  // concrete — inherited as-is
        t.lungs.cycle()

// Concrete implementation
d Circle : Drawable
    radius: N
    f draw(ctx: Context)
        ctx.drawCircle(t.center, t.radius)
    f bounds(): Rect
        r => Rect({ x: t.center.x - t.radius, y: t.center.y - t.radius,
                    width: t.radius*2, height: t.radius*2 })

// Type test works for interfaces
shape: Drawable = Circle({ radius: 5.0 })
shape : Drawable   // L true
shape : Circle     // L true — concrete type also works

// Static interface methods: not allowed — interfaces are for instances
// Use type hierarchies for static polymorphism instead:
d Shape.Circle : Shape
    f create(radius: N): Shape.Circle   // static — called as Shape.Circle.create(5.0)
        r => Shape.Circle({ radius })

f good(data: [N32+V])          // ✓ typed

// f bad(data)  ← ✗ compile error: no type annotation
f fetch(url: S, { timeout: I = 30, verbose: L = false })
// { timeout }  ← ✗ compile error: missing type in named param

// Map literal — runtime key-value store
meta: {S: Any} = { "author": "Alice", "version": 3 }

// Any comparable type as key
userById:  {I: User}    = {}   // integer keys
byPoint:   {Point: I}   = {}   // class key — Point must implement hash() and ==

// Dynamic access — returns +N (key may not exist)
author:  S+N = meta["author"]
version: I    = meta["version"] ?? 1
"author" in meta   // L — O(1) membership

// Modifiers — same as classes
roConfig:  {S: S}+R-M         = loadConfig()   // shared immutable
liveState: {S: Any}+R+M+M(MVCC) = {}            // shared mutable + MVCC

// Class as key — implement hash() and ==
d Point
    x: I, y: I
    f __hash(): I              => (t.x * 31 + t.y) * 31
    f __equals(other: Point): L => t.x == other.x & t.y == other.y

grid: {Point: S} = {}   // works because Point has __hash and __equals
grid[Point({ x: 0, y: 0 })] = "origin"

// .x() — side effects
meta.x((key, val) => log("{key}: {val}"))

// .filter() — returns new Map
strings = meta.filter((key, val) => val : S ? none ! false)

// .map() — transform values, keys preserved
upper = meta.map((key, val) => val : S ? val.uppercase() ! val)

// .find() — returns (K, V) +N
hit: (key: S, val: Any)+N = meta.find((key, val) => val == target ? none ! false)

// .reduce() — fold
total = prices.reduce((acc, key, val) => acc + val, 0.0)

// Promise-aware: .all() and .any() work on {K: V +A} maps
fetching: {S: Response+A} = endpoints.map((key, url) => a fetch(url))
results:  {S: Response}   = fetching.all()   // await all, same keys preserved
first:    Response+N+A  = fetching.any()   // first to resolve

admins: {S: L} = { "alice": true, "bob": true }
"alice" in admins   // true — O(1)
admins["carol"] = true    // add
admins["bob"] = none       // remove

editors: {S: L} = { "bob": true, "carol": true }
both = admins.filter((key, _) => key in editors ? none ! false) // intersection
only = admins.filter((key, _) => key in editors ? false ! none) // difference
all  = admins.c(+M).merge(editors)                                 // union

// No Set<T> type in v1 — no need for one.
// {K: L} maps with the in operator cover all set semantics.

scores: {S: N} = { "alice": 9.8, "bob": 7.4, "carol": 8.1 }

// .x() — iterate (key, value) in insertion order
scores.x((score, name) => print(name + ": " + score.toString()))  // value first
// alice: 9.8 / bob: 7.4 / carol: 8.1 — guaranteed order

// .map() — transform values, key passed through
grades: {S: S} = scores.map((score, name) => score >= 9.0 ? "A" ! "B")

// .filter() — keep entries where predicate holds
topScores: {S: N} = scores.filter((score, name) => score >= 9.0 ? none ! false)

// .all() / .any() — synchronous predicates
allPassed: L = scores.all((score, name) => score >= 5.0)   // true
anyHonours: L = scores.any((score, name) => score >= 9.5)  // false

// .reduce() — fold over entries
total: N = scores.reduce((acc, score, name) => acc + score, 0.0)

// .find() — first matching entry, returns value+N
winner: N+N = scores.find((score, name) => score >= 9.0 ? none ! false)

// .keys() / .values() / .entries() — explicit projection
names:   [S]        = scores.keys()     // [S] in insertion order
vals:    [N]        = scores.values()   // [N] in insertion order
pairs:   [[S, N]]  = scores.entries()  // [[key, value], ...] in insertion order

d User
    id:    I
    name:  S
    email: S

    // Identity by id only — name and email changes don't affect map keys
    f __hash(): I            => t.id
    f __equals(other: User): L => t.id == other.id

    // Serialization — round-trips through __unserialize
    f __serialize(): S
        r => "{t.id}|{t.name}|{t.email}"

    // Class-level factory — called as User.__unserialize(str)
    f __unserialize(data: S): User
        parts = data.split("|")
        r => User{ id: parts[0].toI(), name: parts[1], email: parts[2] }

// Usage
userMap: {User: Session} = {}      // User as map key — uses __hash and __equals

alice = User{ id: 1, name: "Alice", email: "a[at]x.com" }
str   = alice.__serialize()            // "1|Alice|a[at]x.com"
back  = User.__unserialize(str)        // User({ id:1, name:"Alice", ... }
alice == back                          // true — same id, __equals passes


    // Conflict resolution — called when two fibers write same Config
    f __merge(base: Config, theirs: Config): Config
        Config{
            host: theirs.host,             // theirs wins for host
            port: t.port,                  // keep my port
            flags: t.flags.merge(theirs.flags)  // union flags map
        }

// Default: no magic methods needed for simple value types
d Color { r: I, g: I, b: I }         // structural __hash and __equals auto-generated
colorCount: {Color: I} = {}            // just works

// -N default: can never be null — no check emitted
name:  S = "Alice"    // -N: compiler skips null check entirely
count: I = 42

// +N: may be none — must handle before use
user: User+N = findUser(id)

// ?? coalesce — provide fallback value
display = user?.name ?? "Guest"   // S -N (narrowed to non-null)
port    = config.port ?? 8080

// & guard — execute only if non-null
user & sendWelcomeEmail(user)      // runs only if user != none

// ?. safe chain — none propagates through the whole chain
city: S+N = user?.address?.city   // +N if any step is none
name: S    = user?.address?.city ?? "unknown"  // -N with fallback
// Compiler emits exactly 2 null tests (user, address)
// city is -N on User.address, so no test there

// Early return on none — clean handler pattern
f handleLogin(uid: I): Response+N
    user = findUser(uid)
    user ?? r => Response.notFound()  // early return if none
    // user is narrowed to User -N here — no more null checks needed
    session = createSession(user)
    r => Response.ok(session.token)

// Compile error: cannot dereference +N without handling
bad = user.name   // ❌ COMPILE ERROR: user is +N — must check first

// Syntax rules: ? and ! at condition indent level
// Arbitrary spaces after ? or ! to align. Continuations indented.

// Inline
label = count > 1 ? "items" ! "item"

// Multi-line block — last expr in each branch is the value
greeting = time < 12
? name = user.firstName
    "Good morning, " + name      // indented → still in ? branch
! name = user.nickname | user.firstName
    "Good afternoon, " + name    // indented → still in ! branch

// Nested
status = user != none
?   user.active
    ?   "active user"
    !   "inactive user"
!   "no user"

// Switch-like: ! at condition level, spaces after ! for alignment
grade = score >= 90 ? "A"
!       score >= 80 ? "B"
!       score >= 70 ? "C"
!                     "F"

// : type test — expr : Type returns B
shape : Circle    & drawCircle(shape)
shape : Rectangle & drawRect(shape)

// Type dispatch with ?! — replaces switch/match/instanceof
area = shape : Circle
?   Math.PI * shape.radius ^ 2
! shape : Rectangle
?   shape.width * shape.height
!   0.0

// & | ?? — short-circuit value operators
admin  & showAdminPanel()            // guard
valid  & r => compute()             // conditional return
label = user.nickname | user.firstName | "Anonymous"  // fallback
port  = config.port ?? 8080          // null coalesce

// .filter() — three signals
active = users.filter((user) => user.active ? none ! false)     // include if active
first10 = items.filter((item) => (
    taken = taken + 1
    taken <= 10 ? none   // include
    !            true     // stop
))

// .map() — return value is the new element
names = users.map((user) => user.firstName + " " + user.lastName)
doubled = nums.map((num) => num * 2)

// .reduce() — fold
total = orders.reduce((acc, order) => acc + order.amount, 0.0)

// .find() — returns T +N, caller knows what they called
user: User+N = users.find((user) => user.id == target ? none ! false)
user != none & process(user)  // or:  user ?? defaultUser

// .all() — Promise.all: await all +A values, results in input order
pending: [S+A] = urls.map((url) => a fetch(url))    // N concurrent fibers
pages:   [S]    = pending.all()                          // await all, ordered

// .any() — Promise.race: returns T +N +A, caller knows
winner: S+N+A = pending.any()  // first to resolve, or none
winner != none & render(winner)

// .x() stays for events, errors, and side-effect iteration
users.x((user) => log(user.name))    // for-each with side effect
e.x(MyLib.networkPolicies)           // error handler registration
clicks.x((evt) => handleClick(evt))  // event subscription

// Inclusive — both ends included
arr = [1..5]         // [1, 2, 3, 4, 5]
arr = [5..1]         // [5, 4, 3, 2, 1]  — start > end counts down

// Exclusive end
arr = [0...10]        // [0, 1, 2, ..., 9]  (not 10)
arr = [0..10]         // [0, 1, 2, ..., 10] (includes 10)

// Arithmetic is element-wise — produces new array
[0..4]*2             // [0,1,2,3,4]*2 = [0, 2, 4, 6, 8]
[4..0]*2             // [4,3,2,1,0]*2 = [8, 6, 4, 2, 0]
[0...10]*2           // [0,1,...,9]*2  = [0, 2, 4, ..., 18]

// Offset pattern — scalar arithmetic lifts over array
(foo - [1..5]*2).x((i, v) => process(v))  // foo-2, foo-4, foo-6, foo-8, foo-10
(base + [0...n]*stride).x((i, v) => arr[v])  // stride pattern, n steps

// .x() on range — compiler emits tight loop, no allocation
[0...n].x((i, v) => draw(v))
[0...rows].x((row) =>                   // iterate rows
    [0...cols].x((col) =>                // iterate cols
        matrix[row][col] * scale
    )
)

// Array slicing
arr[1..4]              // elements 1,2,3,4 — inclusive
arr[1...4]             // elements 1,2,3 — exclusive end
arr[4..1]              // reversed slice [4,3,2,1]

// Bounded loop with break
w
    event = nextEvent()
    event.isDone & b     // b = break
    process(event)

// Generator function — yields values lazily
f naturals(): I
    num = 0
    w+I             // w+I = intentionally infinite, no warning
        y num        // y = yield
        num = num + 1

// Fibonacci
f fibonacci(): I
    prev = 0
    curr = 1
    w+I
        y curr
        next = prev + curr
        prev = curr
        curr = next

// Consume a generator with .x()
fibonacci().x(n => n > 1000 & b)  // stop when > 1000

// continue skips current iteration
w
    line = readLine()
    line.isEmpty() & c          // c = continue, skip blank lines
    line.startsWith("#") & c   // skip comments
    processLine(line)
    eof() & b

// ── Definition site ───────────────────────────────────────────────────
d NetworkError : BaseError { msg: S, code: I, retryable: L }
d TimeoutError : NetworkError { elapsed: I }

a f fetch(url: S): S ! NetworkError ! TimeoutError
    connected | e NetworkError{ msg: "offline", retryable: true }
    elapsed > limit & e TimeoutError{ elapsed: elapsed }
    r => body

// ── Single and multi-arg ──────────────────────────────────────────────

a f run(url: S)
    e.x(logTimeout, retryOnTimeout)    // push both onto TimeoutError chain
    e.x((err: NetworkError) => err.retryable ? retry(url) ! logAndFail(err.msg))
    result = a fetch(url)
    process(result)

// ── Library policy arrays — ordered, exported, composable ────────────

// In MyLib — exported as arrays, NOT objects (object method order is undefined)
networkPolicies: [(NetworkError)->()] = [
    logToSentry,
    notifyOncall,
    retryOnRecoverable   // order defined and preserved
]

// Call site — array spreads onto chain in order
a f run(url: S)
    e.x(MyLib.networkPolicies)        // spread array: all three appended in order
    e.x(MyLib.networkPolicies, extraHandler) // append more after the array
    result = a fetch(url)
    process(result)

// ── Pit of success — library symbols ─────────────────────────────────

e.x(
    MyLib.handleNetworkError,
    Foo.failClosedOnSyntaxError
)
result = a fetch(url)   // happy path
process(result)

// ── Early exit is per-type, independent chains ────────────────────────

e.x((err: NetworkError) => { reconnect() | (r => false) }) // false = stop NetworkError chain
e.x((err: NetworkError) => logAndFail(err.msg))  // skipped if above returns false
e.x((err: TimeoutError) => retry(url))           // TimeoutError chain unaffected

// ── The rule: declare what you originate, propagation is inferred ─────

// You ORIGINATE this throw → must declare ! NetworkError in your signature
a f fetch(url: S): S ! NetworkError ! TimeoutError
    connected | e NetworkError{ msg: "offline" }   // ← originated here
    elapsed > limit & e TimeoutError{ elapsed }      // ← originated here
    r => body

// You PROPAGATE from a callee → inferred automatically, no declaration needed
a f run(url: S): S                   // no ! needed
    e.x((err: NetworkError) => retry(url))  // handled
    r => a fetch(url)    // TimeoutError propagates — compiler infers it
                         // no ! TimeoutError required in run()'s signature

// Optional: explicitly seal your surface — compiler verifies accuracy
a f run(url: S): S ! TimeoutError   // declares AND verifies: only this escapes

// Block-scoped catching: () is your try block
result = (
    e.x((err: NetworkError) => r => fallback)  // only inside this block
    a fetch(url)
)

// every — false stops chain early
allPaid     = orders.x((order) => order.paid)       // false if any not paid
noneOverdue = orders.x((order) => !order.overdue)   // false if any overdue

// any via De Morgan:  any(f)  =  !every(!f)
hasAdmin   = !users.x((user) => !user.isAdmin)    // true if any user is admin
anyOverdue = !orders.x((order) => !order.overdue)   // true if any order overdue

// Start N concurrent fibers — all run in parallel
pending: [S+A] = urls.x((url) => a fetch(url))

// all — collect all results in input order (auto-await)
pages: [S] = pending.all()       // waits for all, returns [S] in order
// time = max(fetch times), not sum

// any / race — first to resolve wins (returns T +A, not array)
first: S+A = pending.any()       // stops at first resolved — Promise.race

// .all() and .any() are just functions:
// .all() = include all, never stop     — include all, never stop
// .any() = stop at first resolved     — stop at first, return it

// Custom: stop when result passes a condition
bigPage: S+A = pending.x((page) => page.length > 10000 ? page ! none)
// returns first page longer than 10k chars, or continues

// Start as new fiber — get [S] +A back, caller continues
results: [S]+A = a pending.all()

// Rejection: if any fetch throws, e.x() handlers fire
e.x((err: NetworkError) => logAndFail(err.msg))
pages = pending.all()   // any rejection → throws → e.x() above fires

// De Morgan — any(f) = !every(!f) still works on plain arrays
hasAdmin   = !users.x((user) => !user.isAdmin)   // true if any is admin
anyOverdue = !orders.x((order) => !order.overdue)

f buildReport(): S              // plain f — not a f
    data: S+A = a fetchData()  // starts new fiber
    r => render(data)            // auto-awaits — no color infection
// JS: buildReport must be async, every caller must be async, cascade

// ── Declaration: behavioral keyword, not a modifier ──────
a f lookup(key: S): Config+N   // 'a' marks function as suspendable

// ── Form 1: Auto-await (default, zero annotation) ────────
cfg = lookup(key)              // fiber suspends transparently if needed
                               // same CALL instruction regardless of sync/async

// ── Form 2: Async opt-in (a + +A co-required) ────────────
pending: Config+N+A = a lookup(key)  // new fiber, caller continues

// ── TYPE ERRORS ───────────────────────────────────────────
cfg = a lookup(key)           // ❌ 'a' without +A on LHS
pending: Config+A = lookup(key)  // ❌ +A without 'a' at call site

// ── Cooperative yields ────────────────────────────────────
a f heavyWork()
    data.x((item, index) =>
        process(item)
        idx % 1000 == 0 & a;  // yield every 1000 items
    )

a f poll()
    w+I
        checkAndProcess()
        a 5              // yield at least 5ms (literal only)

// Class-level default policy
d AppState+M(MVCC)
    data: [S]

state: AppState+R+M = AppState()  // uses MVCC from class
snap = state.c()             // instant snapshot, no lock
state.update(delta)          // serialized write through proxy

// Binding-site policy — class has no default, policy declared here
inbox: Queue+R+M+M(Actor)  = Queue()
inbox.push(msg)              // enqueued, processed in order

votes: GCounter+R+M+M(CRDT) = GCounter()
votes.increment(nodeId)      // order doesn't matter, same result

// RAII — cleanup fires when last reference drops
d FileHandle+R(RAII)
    fd: I
    f drop(t: FileHandle+R)  // called automatically on last-ref-drop
        os.close(t.fd)

// Override class default at binding site
c1: Counter+R+M          = Counter()  // uses class default
c2: Counter+R+M+M(MVCC) = Counter()  // override

// html — {expr} auto-escaped, XSS structurally impossible
page = html`<h1>{title}</h1><p>{userInput}</p>`  // both escaped ✅
frag = html`<img src="{avatar?}">`                 // {expr?} = omit if none
raw  = html`<div>{{trusted}}</div>`               // {{expr}} = raw unsafe ⚠

// sql — params sent separately, SQL injection impossible
rows = sql`SELECT * FROM users WHERE id = {uid}`
// → sends uid as $1 parameter, never interpolated into the query string

// msg — locale keys and placeholders verified at compile time
hi  = msg`{greeting, name: user.name}`  // ✅ key + placeholder matched
err = msg`{welcome}`                    // ❌ compile error: key not in bundle
er2 = msg`{greeting}`                   // ❌ compile error: {name} missing

// Tags are literals — cannot be stored or passed
tag = html                     // ❌ compile error: html is not a value
f render(tag, data) = tag`{data}` // ❌ compile error: dynamic tags disallowed

// JSON literals in U support /* */ and // comments
config = {
    /* database */
    "host": "localhost",   // local dev
    "port": 5432,           /* default postgres port */
    "name": "mydb"
}

// Also works in json`` template literal for loading dynamic content
data = json`{rawString}`    // strips comments from rawString before parsing

// Arithmetic — safe by default
total = big + small        // overflow-checked
ratio = num / divisor      // zero-checked
item  = arr[index]         // bounds-checked
total = big +! small       // ! = opt out of overflow check
item  = arr[index!]        // ! = opt out of bounds check

// Power — ^ is exponentiation
area  = side ^ 2           // x squared
scale = 2 ^ bits           // 2^n for bit counts
mag   = 10 ^ exponent      // order of magnitude

// Bitwise — all use ~ prefix
masked  = flags ~& 0xFF    // AND bits
merged  = a ~| b            // OR bits
toggled = a ~^ b            // XOR bits
flipped = ~!value           // NOT bits (unary)
shifted = bits ~< 3          // left shift
aligned = bits ~> 2          // right shift

// Mix — ~ prefix makes bitwise vs logical unambiguous at a glance
valid = (flags ~& MASK) & notExpired  // ~& bitwise, & guard

// Copy vocabulary — only these four forms exist
ref = obj            // retain: refcount++ only, zero allocation
ref = obj.c()        // copy: -R props by value, +R props share ref
ref = obj.c(+V)     // domain copy: DMA to GPU memory
ref = obj.c(+R)     // promote: -R stack value → +R heap allocation

// COW: .c() is lazy for -R +M properties — no allocation until write
snap = state.c()           // marks COW intent, no allocation yet
readFrom(snap)             // reads shared data, zero cost
snap.field = newVal        // NOW allocates + copies, then writes

// Copy elision: refcount=1 at .c() call site → zero cost
cfg   = loadConfig()       // +R, refcount=1 (genesis)
local = cfg.c()            // refcount was 1 → compiler elides entirely

// A function with zero annotations
f stats(data: [N]): Stats
    total = data.x((acc, val) => acc + val, 0.0)
    mean  = total / data.length
    r => { total, mean }

// What you get for free, by default:
//  ✅ No null dereference    (-N default)
//  ✅ No heap allocation     (-R default)
//  ✅ No ARC cost            (-R: no refcount)
//  ✅ No race condition      (-R: no sharing)
//  ✅ No dangling reference  (-R: scope lifetime)
//  ✅ No iterator invalidation  (.x(): safe)
//  ✅ Zero-copy return       (r.field = DPS)
//  ✅ No async coloring      (fibers)

a f lookup(key: S): Config+N   // declared async — may suspend

// FORM 1: Auto-await (default, no annotation needed)
cfg = lookup(key)                   // get Config — transparent suspension if needed
// If lookup doesn't suspend: returns Config directly. One branch check.
// If lookup suspends: fiber pauses, resumes when done, cfg gets Config.
// Call site code: IDENTICAL either way. Zero annotation required.

// FORM 2: Async opt-in (explicit, requires +A on left)
pending: Config+N+A = a lookup(key)  // get pending Config
// New fiber starts. Caller continues immediately. pending is a pending Config.
// 'a' and +A are co-required — compiler enforces both or neither.

// TYPE ERROR — 'a' requires +A on LHS
cfg = a lookup(key)            // ❌ 'a' produces Config +A but LHS expects Config
                               //    "remove 'a' — auto-await does this already"

// TYPE ERROR — +A requires 'a' at call site
pending: Config+A = lookup(key) // ❌ LHS is Config +A but call site has no 'a'
                               //    "add 'a' to opt into async domain"

// The error messages write themselves from the rule.
// You cannot have one without the other.

pending: Config+N+A = a lookup(key)

// Auto-resolve: LHS expects Config — triggers resolution
cfg: Config+N = pending               // fiber suspends if still pending

// Copy: stays pending
other: Config+N+A = pending           // no resolution, stays +A

// Chain: schedule work on resolution — returns S +A
rendered: S+A = pending.x(cfg => render(cfg))

// Multiple subscribers — event emitter pattern falls out naturally
pending.x(cfg => log(cfg))
pending.x(cfg => cache(cfg))
pending.x(cfg => notify(cfg))   // all three run when pending resolves
// No EventEmitter class. No .on() method. Just .x().

// ─── PHASE 1: everything sync ─────────────────────────────────
f lookup(key: S): Config     // sync

f handleReq(key: S): S
    cfg = lookup(key)         // [A] CALL → Config immediately
    r => render(cfg)

// ─── PHASE 2: lookup becomes async ────────────────────────────
a f lookup(key: S): Config    // added 'a' — ONLY CHANGE

// handleReq source is IDENTICAL — zero recompile
f handleReq(key: S): S
    cfg = lookup(key)         // [A] same CALL instruction
                              //     fiber suspends if lookup suspends
                              //     cfg gets Config — caller unchanged
    r => render(cfg)

// ─── PHASE 3: a different caller opts into concurrency ────────
f handleBatch(keys: [S]): [S]
    // Explicit async: fan out all lookups concurrently
    jobs: [Config+A] = keys.x(k => a lookup(k))

    // Auto-resolve: [Config +A] used as [Config] triggers resolution
    cfgs: [Config] = jobs

    r => cfgs.x(cfg => render(cfg))

// Phase 3 also stable: if lookup later becomes sync again,
// 'a lookup(k)' produces trivially-resolved Config +A. Still correct.

// Sequential — inline to tight loop by compiler
items.x((item) => process(item))

// Async method reference — a before the ref = async dispatch
items.x(a Cool.processItem)             // backpressure automatic

// Async lambda with block body
items.x(a (item) => (
    result = a fetch(item)              // suspends here if slow
    a db.write(result)                  // suspends again if needed
    log(result)
))
// fiber suspends at each 'a' call — next item waits — that IS backpressure
// no semaphore, no channel, no configuration needed

// Concurrent pool — a before the outer handler
items.x(a (item) => a fetch(item))     // [T +A] — bounded pool
// scheduler fills pool up to limit
// pool full: new items wait — backpressure
// slot frees: next item starts

// Await the whole batch
results: [S] = a items.x(item => a fetch(item))
// outer 'a': don't return until all items resolved

// Pipeline: stages compose naturally
urls
  .x(url    => a fetch(url))    // [S +A] — concurrent, backpressure applied
  .x(result => parse(result))    // [S] — sequential (no 'a' = auto-await per item)
  .x(parsed => store(parsed))    // [void] — sequential sink

// items can be: array, generator, stream, another .x() chain
// backpressure applies uniformly — source type doesn't matter

// Default: sequential, automatic backpressure
items.x(a processItem)

// Opt-in parallel pool — admit up to 10 concurrent
items.x(Concurrency.pool(10), a processItem)

// Drop when full
items.x(Concurrency.dropLatest, a processItem)

// Custom policy — same interface as any handler
myPolicy = (item) => rateLimit.check(item) ?? r => true | r => none
items.x(myPolicy, a processItem)

// CPU-intensive loop — sprinkle a; to stay cooperative
a f processLargeDataset(data: [Item])
    data.x((item, index) =>
        heavyCompute(item)
        idx % 1000 == 0 & a;    // yield every 1000 items
    )

// Timed yield — be nice for at least 5ms
a f pollingLoop()
    w+I
        result = checkForUpdates()
        result & processUpdate(result)
        a 5                         // yield at least 5ms between polls

// a n is a lower bound — scheduler may not wake you in exactly n ms
// Only hurts your fiber and callers — cannot harm other fibers
// Callers defend with: job: T +A = a pollingLoop() — runs on own fiber

// Independent computations — scheduler runs concurrently
cfg:    Config+A = a loadConfig()
schema: Schema+A = a loadSchema()   // independent of cfg

// Dependent — scheduler waits for both before running render
page:   S+A      = a render(cfg, schema)

// The scheduler reads the type graph:
// page depends on cfg and schema
// cfg and schema are independent
// → run loadConfig + loadSchema concurrently
// → run render when both resolve
// Zero manual dependency declaration.
// The dependency graph IS the program.

// RAII: drop() fires deterministically on last ref
d DbConn+R(RAII)
    handle: I
    f drop(conn: DbConn+R) => db.close(conn.handle)

f query(sql: S): S
    conn: DbConn+R = DbConn.open()   // refcount=1
    result = conn.exec(sql)
    r => result    // conn refcount→0: drop() fires, connection closed
    // No finally, no try-with-resources, no defer

// MVCC: readers never block, writers get a new version
config: AppConfig+R+M(MVCC) = AppConfig.load()
config.reload()   // new version; existing readers see old version until done

// Actor: all access serialized through message queue
d Counter+M(Actor)
    count: I+M = 0
    f increment() => t.count = t.count + 1
    f get(): I   => r => t.count
// Concurrent callers are queued — no data race, no mutex annotation

// +R +M defaults to MVCC — no annotation needed
config: Config+R+M = Config.load()

d Config
    host:  S            // inline -R — atomic with Config
    port:  I+M         // inline -R — atomic with Config
    flags: {S: L}       // inline map — atomic with Config
    cache: Cache+R(RAII)  // separate heap object — its own versioning

// Writing host + port + flags atomically — one version, one commit
config.host  = "newhost"
config.port  = 9090
config.flags["debug"] = true
// All three committed as one unit — other fibers see old or new, never partial

// Atomic multi-field patch — one MVCC version swap
config << { host: "newhost", port: 9090 }   // atomic, retries on conflict

// Nested inline — recursively patches -R fields
server << { address: { host: "new" }, port: 443 }   // address.scheme unchanged

// Array element patch — O(log n), structural sharing
items << { [500]: updatedItem }   // path-copies only the path to index 500

// Two concurrent fibers — no conflict if different indices
// Fiber A: items << { [500]: valA }   ✅ different subtrees
// Fiber B: items << { [700]: valB }   ✅ both commit

// On -R local: same syntax, no MVCC overhead (compiler knows)
localConfig << { port: 9090 }   // plain field update, -R = no versioning

e.x((err: ValidationError) => (
    log(err.msg)
    r => true    // handled — writes committed, fiber continues
))
e.x((err: CorruptStateError) => (
    alert(err.msg)
    // returns none — unhandled, writes rolled back, propagates up
))

// Fail closed: forgetting to return true = rollback, not silent commit
// You must consciously affirm the write-set is valid

// Policies are typed arrays — defined once, reused everywhere
networkPolicies: [(NetworkError)->()] = [
    logToSentry,         // ordered, defined by library
    notifyOncall,
    retryOnRecoverable
]

// Every call site — one line, happy path clean
a f run(url: S)
    e.x(MyLib.networkPolicies)     // spread array onto chain
    e.x(MyLib.sslPolicies)         // multiple arrays composable
    // compiler: all ! NetworkError ! SSLError covered ✅

    result = a fetch(url)          // happy path reads first, clean
    process(result)

// Inheritance: ! NetworkError covers TimeoutError : NetworkError
// No need to list every subtype — the Java checked-exception trap avoided
// Zero-cost happy path — handler tables built statically, no stack unwinding

// +R(RAII): drop() called automatically when last +R ref drops
d FileHandle+R(RAII)
    fd: I
    f drop(t: FileHandle+R)   // compiler calls this on last-ref-drop
        os.close(t.fd)

// No defer, no try-with-resources, no explicit close()
f readConfig(): S
    fh: FileHandle+R = open("/etc/config")  // refcount=1
    data = fh.read()
    r => data    // fh refcount→0 here: drop() fires, fd closed

// vs C++: shared_ptr uses atomic refcount (expensive cross-thread)
// U: ARC is plain integer arithmetic — no atomics (single-threaded fibers)

// Swift: async infects callers — coloring present
// func fetchData() async throws -> Data { ... }
// let data = try await fetchData()  // caller must be async
// — every function in the chain must be marked async

// U: no coloring — any function can call any function
a fetchData(): S+N   // only fetchData is marked 'a'
f main()               // NOT marked 'a' — no annotation needed
    data = a fetchData() // 'a' is at the call site, not on main()

// Swift: withTaskGroup for concurrent iteration (verbose)
// await withTaskGroup(of: Data.self) { group in
//     for url in urls { group.addTask { await fetch(url) } }
// }

// U: .x() with +A return — automatic, zero ceremony
results = a urls.x(url => fetch(url))  // done

d Article { title: S, body: S, author: S }

a f loadDashboard(ids: [I])
    // Error policy declared upfront — happy path reads clean below
    e.x(MyLib.networkPolicies)    // typed array: [log, notify, retry]
    e.x((err: NotFoundError) => showEmpty())

    // Start N concurrent fetches — map returns [Article +A]
    pending: [Article+A] = ids.map((id) => a fetchArticle(id))

    // Await all — input order preserved, time = max not sum
    articles: [Article] = pending.all()

    // Any rejected fetchArticle → NetworkError → e.x() fires above
    // No .catch(), no try/catch, no Promise.all().catch() dance
    render(articles)

a f loadConfig(): Config
    e.x((err: NetworkError) => r => Config.defaults())

    cache: Config+N+A = a fetchFromCache()
    remote: Config+N+A = a fetchFromNetwork()

    winner: Config+N+A = [cache, remote].any()
    r => winner ?? Config.defaults()

d ClickEvent { x: I, y: I, button: I }
d ResizeEvent { width: I, height: I }

d Canvas+R(RAII)
    clicks:  ClickEvent+A+R
    resizes: ResizeEvent+A+R

    f drop(canvas: Canvas+R)   // fires when last ref drops
        canvas.clicks.unsubscribe()   // cleanup automatic

canvas: Canvas+R = Canvas.create()

// Error policy for canvas event handlers
e.x((err: RenderError) => logAndSkip(err))

canvas.clicks.x((evt) => paint(evt.x, evt.y))
canvas.clicks.x((evt) => logInteraction(evt))
canvas.resizes.x((evt) => relayout(evt.width, evt.height))
// No unsubscribe logic — RAII handles it when canvas scope exits

config: AppConfig+R+M(MVCC) = AppConfig.load()

// N concurrent workers — all reading config simultaneously
pending: [Result+A] = jobs.map((job) => a runJob(job, config))
results: [Result]   = pending.all()

// Hot-reload fires while workers are running
config.reload()   // MVCC: new version; in-flight workers see old version
// No mutex, no lock, no blocking. Policy handles it.