[name] is [age] years old, born in [2026 - age]` - **`[...]` inside string literals is also evaluated.** `'hello [name]'` is interpolation, not a literal. To keep literal bracket text, escape it: `'pages/blog/\[slug].rat'`. Unescaped unknown names interpolate to empty string silently - a classic source of vanishing text. - `<<` is **assignment / write**: `count << count + 1`, and **return** in a function body: `<< 'zero'`. - **Compound assignment**: `+= -= *= /= %=` and postfix `++` / `--` are sugar for `lhs << lhs OP rhs` - they work everywhere `<<` does (function bodies, service methods, handlers) on any lvalue: `n += 1`, `total *= 2`, `i--`. - **Index / member assignment**: `m[k] << v` and `m.field << v` write a map key or object field; `xs[i] << v` and `grid[r][c] << v` write array elements. Compound forms apply too: `m[k] += 1`, `xs[i]++`. A `+=` on a missing key reads it as 0 (`m[k] += 1` on an absent `k` yields 1) - same forgiveness as any null-in-arithmetic. `m[k]` is pure sugar for `get`/`put`/`at`/`set`. - **Multi-return + destructure**: `<< a, b, c` returns `[a, b, c]`; the call site unpacks with `[x, y, z] << f()` (fresh locals, positional). A null return binds every name null; short arrays null-fill, long ignore extras. Top-level commas only - `<< f(a, b)` is a single call, not a pair. - `>>` declares a **derived field** (`double >> count * 2` - recomputes reactively) and is the **one-liner function body** marker. - `++` increments: `on_click[count++]`. - Comparison: `== != < <= > >=`. Null checks read as prose: `(user is not null)`, `(x is null)`. - Logic: `&` (and), `|` (or), parenthesize compound conditions: `((a == b) & (i > 0))`. - Arithmetic: `+ - * / %`. String concat is `+`: `greeting >> 'Hello, ' + name + '!'`. - Statement separator inside a handler bracket is `;`: `on_click[items.add(draft); draft << '']`. - Side-effect tap: `total << sum(xs) >> log('total: [total]')` - the `>>` tail runs for effect without changing the assigned value. --- ## 5. Markup rules (where HTML intuition betrays you) - Tags look like HTML but **prose must stay on the tag's own line**: `

`, an ``), any
  statement in a fn body (e.g. `[count] << len(xs)`).
- **A matching branch that doesn't return still consumes the chain.**
  In fn bodies a normalization guard (`(t == 'coral') t << 'a'`) placed
  adjacent to an independent validation guard swallows it - the
  validation never runs on the normalized path. Audit every chain for
  "matches, doesn't return, next guard still needed"; break the chain
  with a statement between the two questions.
- Loops bind with `[item] in collection` on its own line; the body indents:

```rat

    [item] in items
        (len(item) >= 5)
             [item]
```

- Guards and loops nest freely in both directions. Empty collections render
  nothing. Loop bodies are reactive (`[u.name]` inside a loop patches per
  element), but **nested reactive loops are not supported** - keep loop
  bodies flat.
- A loop is reactive when its collection is page-tier state: a flat name
  (`[s] in items`) or a dotted path rooted at one (`[e] in board.entries`).
  Both re-render on mutation (`items.add(x)`, `board.entries.add(x)`).
  Server-tier collections render once server-side, flat or dotted.
- In functions, the same forms drive logic (see next section).
- **`break` / `continue`** work inside a loop in a function or handler body:
  `break` stops the innermost loop, `continue` skips to the next iteration.
  Use as a guard action (`(cond) break`) or on their own line. They unwind
  only the nearest loop. (Page-template loops render every element - loop
  control is for computational bodies, not markup.)
- **`while (cond)`** is the condition loop (re-checked each pass);
  **`while [i] (cond)`** adds a free read-only pass counter `i` (0,1,2,…),
  loop-scoped, exit still on `(cond)`. **`inf`** is a real +Inf value, so
  **`[i] in inf`** is the infinite loop (exit via `break`/`<<`) and
  `best << inf` seeds a min-search (`-inf` for max). Every count/while loop
  is bounded by a hard iteration ceiling - a runaway loop errors loudly,
  never hangs SSR.

---

## 7. Functions and lambdas

```rat
# multi-line: body indents, locals via [name] <<, return via <<
> add[a, b]
    [sum] << a + b
    << sum

# one-liner: >> is the whole body
> double[x] >> x * 2

# first-match guard chain as function logic
> sign[n]
    (n > 0) << 'positive'
    (n < 0) << 'negative'
    << 'zero'
```

- Declared at top level with `> name[params]`. No imports, no registration -
  callable from any page, pup, service, or handler.
- Missing args arrive as `null`. Both `[x] << ...` and a plain `x << ...`
  for a NEW name are function-local - a helper's locals never leak into or
  clobber the caller's. Writing a name that already exists as server/page
  state still reaches that state (the local rule is for new names only).
- Lambdas for collection builtins: `filter([1,2,3,4], fn[n] >> n % 2 == 0)`.
- Loop + guard inside a body:

```rat
> first_admin[users]
    [u] in users
        (u.admin) << u
    << null
```

- **Do not** put `fn[...]` lambdas inside `> server` state initializers -
  `sum(map(arr, fn[x] >> x.field))` in a server line does not evaluate.
  Write a named helper function with an explicit loop instead.
- Dotted function names (`> channel.on_connect[...]`) are reserved for
  framework hooks; don't invent your own dotted declarations.

---

## 8. Pups (components)

Any `.rat` file under `pups/` becomes a tag named after the file.

```rat
# pups/greeting.rat
> server
tagline: 'hello'        # default, overridable per call site

> page
 [tagline], friend.
```

```rat
# usage in any page


```

- Call-site attributes become the pup's variables.
- `` splices caller markup; the children evaluate in the
  **caller's** scope.
- Pups can hold their own `> page` state + handlers; each instance is
  independent.
- Don't name a pup prop `title` - it collides with the page-level `title`
  server var. Use `heading` / `caption`.

---

## 9. Services

A service is a named singleton with state and methods, conventionally
declared in `main.rat`. It survives across requests (server frame).

```rat
> service [auth]
user: null
token: null

login[u, p]
    user << u
    token << 'tok-' + p
    << true

logout[]
    user << null

is_authed[] >> token is not null
```

- Call from anywhere: `auth.login(name, pw)`, read state: `[auth.user]`.
  Reads participate in the reactive graph.
- Methods inside the block do NOT take the `>` prefix; one-liners use `>>`.
- **Never name service methods** `add`, `push`, `pop`, `clear`, or `remove`
  - the handler compiler rewrites `name.add(...)`-shaped calls as array
  mutations and your service method will never be called.
- **Service-method calls don't work directly in event-handler attributes
  in all cases.** `on_click[svc.method(x)]` works for simple cases, but the
  reliable pattern is a top-level wrapper function:

```rat
> run_analyze[s]
    text_demo.analyze(s)

# in the page