// 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())
// ✅ 1-based indexing          (arr[1] = first, arr[arr.length] = last)

// LLM generates a plugin at runtime:
plugin: SummaryPlugin+A = a o(llm_generated_path, {
    Templates,                   // grant: can use template tags
    Network.LLM.Summariser       // grant: can call the summariser LLM
    // NOT granted: FileSystem, Network.HTTP, Network.SMTP
})
// If LLM plugin tries to fetch("https://exfiltrate.evil.com") → CapabilityError
// If LLM plugin tries to send email → CapabilityError
// If LLM plugin passes S where Templates.HTML expected → type error
// All caught before execution. Zero runtime damage.

// 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 old_version(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  = Q(1,3)       // D  exact decimal, no float rounding
msg    = "Hello!"    // S  UTF-8 string
alive  = true        // L  logical
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

// Compile-time validated and pre-compiled:
email = regex`[a-z]+@[a-z]+\.[a-z]+`i    // Regex — flag i after backtick
digits = regex`\d+`
spaces = regex`\s+`g

match = email.match(input)                // returns [S]+N
clean = spaces.replace(text, " ")

// Compose Regex sub-patterns via interpolation:
prefix: Regex = regex`[A-Z]{2,4}`
code:   Regex = regex`\d{3}`
full:   Regex = regex`{prefix}-{code}`  // ✓ Regex in regex`` = safe composition

// Compile error — S not allowed in regex context:
// pat: S = "\d+"
// broken = regex`{pat}`   ✗ S cannot be interpolated into regex``

// Invalid pattern = compile error:
// bad = regex`[unclosed`  ✗ syntax error at compile time, not runtime

// = is symbolic by default — no IEEE arithmetic yet:
result = Q(1,3) * Q(3,5)   // Q(Q(1,3), Q(3,5)) — symbolic
chain  = result / Q(2,7)    // still symbolic — one more level

// =! materialises NOW:
flat  =! chain              // ONE IEEE division — maximally stable
num: N  = chain             // auto-materialises to float
chain.__string__()            // auto-materialises for display

// Exact comparisons — always correct:
Q(1,10) + Q(2,10) == Q(3,10)   // TRUE — 0.1+0.2==0.3
Q(1,3) * 3 == Q(1,1)         // TRUE — 1/3 * 3 == 1

// I / I returns Q — no silent truncation:
third  = 1 / 3              // Q(1,3) — not 0
1 // 3                      // floor division → I(0)

// Special values:
Q(1, 0)   // w (positive infinity)
Q(-1, 0)  // -w (negative infinity)
Q(0, 0)   // none (undefined)
Q(1, w)   // 0 in the limit (infinitesimal)

// 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
new_config = Config( ...config, host: "newhost" )
new_map    = { ...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  — indexed 1..3

// 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 = do_first_thing()
    step2 = do_second_thing(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 = submit_order(
    order_id,
    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.strip()
    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 build_user(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 apply_twice(fn: F(I)->I, val: I) -> I
    r => fn(fn(val))

result = apply_twice(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 named
fetch("api.com", 5, { timeout: 60, verbose: true }) // two named

// 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 weird_func(x: I, opts: FetchOpts, y: S)     // explicit, named
weird_func(5, FetchOpts( timeout: 60 ), "hi")

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

// Fields without default → positional. Fields with default → { } bag.
d User
    id:    I             // required — positional in __construct__
    name:  S             // required — positional
    email: S = ""        // optional — goes in { } bag
    admin: L = false     // optional — goes in { } bag

// Auto-generated __construct__ (what the compiler produces):
// f __construct__(id: I, name: S, { email: S = "", admin: L = false })

// Call sites:
alice = User(1, "Alice")                              // required only
bob   = User(2, "Bob", { email: "[email protected]" })          // one optional
admin = User(3, "Admin", { email: "[email protected]", admin: true }) // two optional
guest = User(opts_bag)                                  // variable works too — destructured

// Custom __construct__ — same rule, just written explicitly:
d Config
    host:  S = "localhost"
    port:  I = 8080
    debug: L = false

    f __construct__({ host: S = "localhost", port: I = 8080, debug: L = false })
        validate(t.port > 0)                            // custom logic before init

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

// Array iteration: (value, index) passed, handler takes only value
nums = [10, 20, 30]
nums.x((n: I) => print(n.__string__()))     // index silently dropped
nums.x((n: I, i: I) => print(i.__string__() + ": " + n.__string__()))  // 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 make_multiplier(factor: I): (I)->I
    r => (num: I) => num * factor    // captures factor (I is -R, value-copied in)

double = make_multiplier(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 on_click()                    // 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)->()] = [log_to_sentry, retry_on_recoverable]  // array

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

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

// w — wield (emit from generator)
f evens() -> I+W
    num = 2
    [1..w].x(() => (
        w num              // w value — emit to caller
        num = num + 2
        none               // continue
    ))

// o — import / capability
o Math.Linear                        // import module
o { Network.HTTP }                   // with capability
o => { evens, Stack }               // export

// c — compile-time function
fetch_cached = c memoize(fetch_data, 60)  // c f HOF, zero overhead

// none — the null value (multi-letter literal)
maybe_user: 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 find_user(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 = load_config()
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)
simd_vec: [N32]+V = load_data()                  // CPU SIMD — data stays on CPU
gpu_vec:  [N32]+R(GPU) = simd_vec.c(+R(GPU))   // copy to GPU device memory
run_kernel(gpu_vec)                                 // dispatches as GPU warps

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

// +A survives fiber suspension
a handle() -> Response
    buf: [L]           = alloc(4096)  // -A: stack-local, NOT saved at suspension
    state: Req+R+A   = build_req()   // +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 unit_circle() -> Circle         // no t → +G, called as Geometry.unit_circle()
        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.unit_circle()         // direct
c = some_circle.unit_circle()       // 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(load_from_file)       // Config +F(path: S)
hooks.append(load_from_env)        // Config +F()
hooks.append(load_with_default(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) = parse_config  // takes S, returns Config
cfg = parser(raw_json)

// ── 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
esc_async: 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 get_handler(server: Server+R) -> Response+F(Request)+R
        r => req => t.handle_request(req)   // captures t — needs +R

handler: Response+F(Request)+R = server.get_handler()
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(MVCC) = Counter()   // override to MVCC

// Policy + inheritance combined
d LiveCounter+M(Actor) : Counter
    last_updated: 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.__string__()
    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

// Type suffix recommended for generic names:
d Stack[ElemType]
    items: [ElemType]+M = []
    f push(item: ElemType)     t.items = [...t.items, item]
    f pop() -> ElemType+N        r => t.items.length > 0 ? t.items.last() ! none

d Result[OkType, ErrType]
    value: OkType+N
    error: ErrType+N
    f ok() -> L   r => t.error == none

// Domain names valid when context is clear:
d Graph[Vertex, Edge]
    nodes: [Vertex]+M = []
    edges: [Edge]+M   = []

// Modifiers validate at instantiation:
d VectorStore[ElemType]
    data: [ElemType+V]+R(GPU)   // ElemType must be numeric

VectorStore[N32]()   // ✓
VectorStore[S]()     // ✗ compile error: S+V invalid

// Generic functions use interfaces instead:
d Comparable!
    f compare_to(other: Comparable) -> I
f max(a: Comparable, b: Comparable) -> Comparable
    r => a.compare_to(b) > 0 ? a ! b

// 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)   => draw_circle(s.radius))
renderer.x((s: Shape.Rect)     => draw_rect(s.width, s.height))
renderer.x((s: Shape.Triangle) => draw_triangle(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)       => alert_security())
// errors and enums are the same pattern. one mechanism.

d Config
    api_url:  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.draw_circle(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: V} = { "author": "Alice", "version": 3 }

// Any comparable type as key
user_by_id:  {I: User}    = {}   // integer keys
by_point:   {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
ro_config:  {S: S}+R-M         = load_config()   // shared immutable
live_state: {S: V}+R+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, val, key) => 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

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.__string__()))  // 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
top_scores: {S: N} = scores.filter((score, name) => score >= 9.0 ? none ! false)

// .all() / .any() — synchronous predicates
all_passed: L = scores.all((score, name) => score >= 5.0)   // true
any_honours: 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() / .items() — explicit projection
names:   [S]        = scores.keys()     // [S] in insertion order
vals:    [N]        = scores.values()   // [N] in insertion order
pairs:   [[S, N]]  = scores.items()  // [[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 __unpack__
    f __pack__(): {S: JsonValue}
        r => "{t.id}|{t.name}|{t.email}"

    // Class method (c f) — called as User.__unpack__(data)
    c f __unpack__(data: {S: JsonValue}) -> User
        parts = data.split("|")
        r => User( id: parts[1].to_i(), name: parts[2], email: parts[3] )

// Usage
user_map: {User: Session} = {}      // User as map key — uses __hash__ and __equals__

alice = User( id: 1, name: "Alice", email: "a[at]x.com" )
packed = alice.__pack__()                // { id: 1, name: "Alice", email: "[email protected]" }
back  = User.__unpack__(packed)        // 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
color_count: {Color: I} = {}            // just works

// 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.first_name
    "Good morning, " + name      // indented → still in ? branch
! name = user.nickname | user.first_name
    "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    & draw_circle(shape)
shape : Rectangle & draw_rect(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  & show_admin_panel()            // guard
valid  & r => compute()             // conditional return
label = user.nickname | user.first_name | "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.first_name + " " + user.last_name)
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 ?? default_user

// .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)

// .sort() — three overloads by lambda arity
nums    = [3, 1, 4, 1, 5]
sorted  = nums.sort()                     // natural order: [1, 1, 3, 4, 5]
rev     = nums.sort(reverse: true)        // reversed:      [5, 4, 3, 1, 1]

users   = [User(name:"Bob",age:30), User(name:"Ali",age:25)]
by_age  = users.sort(u => u.age)          // key fn (1-param lambda) → ascending by age
by_name = users.sort(u => u.name)         // key fn → lexicographic
by_custom = users.sort((a, b) => a.score > b.score)  // comparator (2-param lambda → L)

// Overload selected purely from lambda arity — no return type needed:
//   ()          → .sort()   natural
//   (reverse:L) → .sort()   reversed
//   (T)         → .sort()   key function
//   (T,T)       → .sort()   comparator

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

// Inclusive — both ends included
arr = [1..5]           // [1, 2, 3, 4, 5]
arr = [5..1]           // [5, 4, 3, 2, 1] — descending

// Exclusive end
arr = [1...6]          // [1, 2, 3, 4, 5]  (not 6)
arr = [1..6]           // [1, 2, 3, 4, 5, 6] (includes 6)

// Arithmetic is element-wise
[1..5]*2               // [2, 4, 6, 8, 10]
[5..1]*2               // [10, 8, 6, 4, 2]

// .x() on range — compiler emits tight loop, no allocation
[1..n].x((val) => draw(val))
[1..rows].x((row) =>                    // rows 1 through rows
    [1..cols].x((col) =>                 // cols 1 through cols
        matrix[row][col] * scale         // 1-based index — natural
    )
)

// Array slicing uses .slice(), not range subscript syntax:
arr.slice(2, 4)           // elements at indices 2, 3, 4 (inclusive)
arr.slice(1, arr.length)   // all elements
arr.slice(-3)             // last 3 elements

// Generator function — w value emits, then continues
f naturals() -> I+W
    num = 1
    [1..w].x(() => (
        w num         // emit, then continue
        num = num + 1
        none          // continue
    ))

// Fibonacci
f fibonacci() -> I+W
    prev = 1
    curr = 1
    [1..w].x(() => (
        w curr
        next = prev + curr
        prev = curr
        curr = next
        none
    ))

// Consume with .x() — return true to stop, none to continue
fibonacci().x(n => n > 1000 ? true ! none)

// Take first N
fibonacci().take(10).x(n => print(n))

// Skip blank lines — return none to continue, process otherwise
f process_lines(lines: [S]+W)
    lines.x(line => (
        line.is_empty() ? none               // skip
        ! line.starts_with("#") ? none        // skip comments
        ! process_line(line) | none          // process, continue
    ))

// w value = wield: emit to caller, continue running
f fib() -> I+W
    prev = 1
    curr = 1
    [1..w].x(() => (
        w curr                   // wield: emit, then continue
        next = prev + curr
        prev = curr
        curr = next
        none                     // continue
    ))

// Infinite range arithmetic:
evens: I+W = [0..w]*2          // 0, 2, 4, 6, ...
neg_e: I+W = [0..−w]*2         // 0, -2, -4, ...

// +W propagates; .take() terminates it:
fib().take(10).x(num => print(num))
big = fib().filter(num => num > 100 ? none ! false).take(5)

// .reduce() .sort() .last() .all() on +W = compile error (needs finite)

// ── 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(log_timeout, retry_on_timeout)    // push both onto TimeoutError chain
    e.x((err: NetworkError) => err.retryable ? retry(url) ! log_and_fail(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)
network_policies: [(NetworkError)->()] = [
    log_to_sentry,
    notify_oncall,
    retry_on_recoverable   // order defined and preserved
]

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

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

e.x(
    MyLib.handle_network_error,
    Foo.fail_closed_on_syntax_error
)
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) => log_and_fail(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
all_paid     = orders.x((order) => order.paid)       // false if any not paid
none_overdue = orders.x((order) => !order.overdue)   // false if any overdue

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

// Compiler sees these BEFORE generating fetch() code:
e.x(log_timeout)                              // TimeoutError → log_timeout
e.x((err: NetworkError) => retry(url))      // NetworkError  → retry_handler
e.x(network_policies)                         // array — flattened at compile time

// Normal execution — ZERO overhead:
result = fetch(url)   // just a function call. no try block. no stack frame metadata.
process(result)       // just a function call.

// On throw — compile-time dispatch table, O(1):
// NetworkError → dispatch_table[NetworkError] → retry_handler(err)
// TimeoutError → dispatch_table[TimeoutError] → log_timeout(err)
// No stack scanning. No unwinding. No DWARF metadata. Direct call.

// 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
big_page: 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) => log_and_fail(err.msg))
pages = pending.all()   // any rejection → throws → e.x() above fires

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

f build_report() -> S              // plain f — not a f
    data = a fetch_data()           // starts new fiber — type inferred: S+A
    r => render(data)            // auto-awaits — no color infection
// JS: build_report 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 inferred from a) ────────────
pending: Config+N+A = a lookup(key)  // new fiber, caller continues

// ── Both call forms work from any context ─────────────────
result  = lookup(key)              // blocks inline — no a f on caller needed
pending: Config+N+A = a lookup(key) // cactus branch — no a f on caller needed

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

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

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

// Error dispatch — fires when a typed error value arrives:
e.x((err: NetworkError) => reconnect())
e.x((err: TimeoutError)  => retry())

// Promise dispatch — fires when a typed success value arrives:
pending = a fetch(url)    // S+A — inferred
pending.x((result: S) => process(result))     // same pattern, different type
pending.x((err: NetworkError) => handle(err)) // errors also dispatched by type

// Event stream — fires repeatedly as typed values arrive:
stream = a watch_clicks()
stream.x((e: ClickEvent)  => handle_click(e))
stream.x((e: ScrollEvent) => handle_scroll(e))
// Same .x() dispatch — type determines handler

p1: S+A    = a fetch(url1)    // node: no inputs
p2: Data+A = a parse(p1)     // node: fires when p1 resolves
p3: Html+A = a render(p2)    // node: fires when p2 resolves
p4: S+A    = a fetch(url2)    // node: no inputs — runs concurrently with p1

result = [p3, p4].all()         // join: fires when BOTH chains complete

// Execution order derived entirely from +A types:
// p1, p4 → concurrent (no dependencies)
// p2     → after p1
// p3     → after p2
// result → after p3 AND p4

// ── Sequential pipeline — full backpressure by default ───────────────
urls.x((url: S) =>                   // .x() waits for each before next
    html:   S                = fetch(url)       // auto-await
    data:   PageData         = parse(html)      // auto-await
    result: Templates.HTML   = render(data)     // auto-await
    store(result))
// One URL at a time. Render slow → parse waits → fetch waits → .x() waits.

// ── Fan-out pipeline — concurrent stages, bounded join ───────────────
pages: [Templates.HTML] = urls
    .map((url) =>                         // fire all fetches concurrently
        html:   S+A               = a fetch(url)
        data:   PageData+A       = a parse(html)   // waits for its own fetch
        result: Templates.HTML+A = a render(data)  // waits for its own parse
        r => result)
    .all()                                // wait for ALL — bounded
// N URLs fetch concurrently. But within each URL: fetch→parse→render is ordered.
// Backpressure within each lane. Join waits for the slowest lane.

// ── Race — first result wins ──────────────────────────────────────────
fast: User+N = [
    a db.query("SELECT * FROM users WHERE id={id}"),
    a cache.get("user:" + id),
    a search_index.find(id)
].any()                                   // first to resolve wins

// ── Toposort falls out of +A types ───────────────────────────────────
prices:  PriceData+A  = a fetch_prices()            // no deps → fires immediately
user:    UserData+A   = a fetch_user(user_id)       // no deps → fires immediately
tax:     TaxRate+A   = a get_tax_rate(user)        // waits for user
total:   Total+A     = a calculate(prices, user, tax) // waits for all three
receipt: Templates.HTML+A = a render_receipt(total) // waits for total

// Scheduler infers topological order:
// Tier 0: prices, user (concurrent, no deps)
// Tier 1: tax (after user)
// Tier 2: total (after prices + user + tax)
// Tier 3: receipt (after total)
// Critical path: max(prices, user) + tax + calculate + render
// You wrote data dependencies. The execution order is derived. No scheduler config.

// 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(Actor)  = Queue()
inbox.append(msg)              // enqueued, processed in order

votes: GCounter+R+M(CRDT) = GCounter()
votes.increment(node_id)      // 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(MVCC) = Counter()  // override

// Leaf component — pure function returning Html:
f badge(user: User) -> Html
    r => user.admin ? html`<span class="badge">{user.role}</span>` ! html``

// [Html] — map returns array, template concatenates:
f product_list(products: [Product]) -> Html
    r => html`
        <ul>
            {products.map((p) => html`<li>{p.name} — {p.price}</li>`)}
        </ul>
    `

// Compose — Html values wire together, [Html] flattens:
f page(title: S, user: User, products: [Product]) -> Html
    cards: [Html] = products.map(product_card)   // each returns Html
    r => html`
        <h1>{title}</h1>
        {badge(user)}
        <div class="grid">{cards}</div>
    `

// External file — compiler reads at build time, validates params:
page  = Template.html("templates/page.html",   { title, content, user })
report = Template.sql("queries/report.sql",   { start_date: D, end_date: D })
theme  = Template.css("styles/theme.css",     { brand: Color, spacing: N })
icon   = Template.svg("assets/star.svg",     { size: N, fill: Color })

// External HTML can contain full U expressions — not just {placeholder}:

<h1>{title}</h1>
<ul>
    {items.map((item) => html`<li class="{item.type}">{item.name}</li>`)}
</ul>
{featured ? html`<div class="hero">{featured.name}</div>` ! html``}

// Import entire locale directory — all languages bundled, runtime selects:
Locale = Templates.localized("i18n/")

// Each key becomes a typed property or function:
Locale.greeting({ name: user.name })        // key with {name} placeholder → S
Locale.button.submit                        // no params → S directly
Locale.error.not_found({ id: item_id })       // nested key, typed param → S

// en.json — primary locale (all others validated against this):
// { "greeting": "Hello, {name}!", "button": { "submit": "Submit" } }
// fr.json missing "greeting" → compile error
// de.json has wrong placeholder type in "greeting" → compile error