Kite

An error you have not checked makes the value unreadable

Go's (T, error) shape is right: failures are ordinary values and every one is visible in the source. Its flaw is that nothing enforces it — and the value on a failure path is a zero value that flows onward looking valid.

use std/json

fn title_of(document: str) -> (str, error) {
    let (parsed, err) = json.parse(document)
    // `parsed` cannot be read yet: on the failure path there is no value at all.
    check err
    return json.text_or(parsed, "title", "untitled"), nil
}

Reading parsed before the check is E0301. Letting err go out of scope unexamined is E0302.

A type that checks the answer, not one that assumes it

axios.get<Basket>(url) is a claim, not a check. TypeScript writes the type in and never looks at a field, so a server that stops sending total produces an undefined somewhere later — far from the request that caused it.

use std/json

@derive(Decode)
struct Basket {
    sale_id: str
    total: int
}

fn basket_of(body: str) -> (Basket, error) {
    let (answer, err) = json.parse(body)
    check err
    return Basket.decode(answer)
}

A body without total comes back as Basket.total: expected a whole number — at the request, naming the field. The decoder is written from the struct, so unlike a hand-kept validation schema there is no second copy to drift.

It is strict on purpose: a missing field fails the whole value. That is right for a server whose columns cannot be null, and wrong for one that may legitimately leave a field out — which wants a reader written by hand. Worth deciding rather than discovering.

Concurrency is one concept

Some operations take time: mark them async and await them. Calling one yields a Task<T> and does not run its body — await is what drives it, and two tasks awaited together overlap. There are no channels, no goroutines and no select.

let a = fetch("alpha", 100)
let b = fetch("beta", 50)
let (first, second) = await task.both(a, b)   // 100ms, not 150

The source never says how many threads exist. Share — a marker the compiler infers structurally — is what will make the same program parallel on the web the day shared-everything-threads ships.

Exhaustive matching, and a compiler that names what is missing

enum Shape {
    Circle(radius: float)
    Rect(width: float, height: float)
    Point
}

fn area(s: Shape) -> float {
    return match s {
        Circle(r) => 3.14159 * r * r,
        Rect(w, h) => w * h,
        Point => 0.0,
    }
}

Leave out Point and the error names it. That is what makes adding a variant safe: the compiler shows every place that must change.

Immutable by default

let bindings and struct fields are immutable unless marked var. That maps directly onto WasmGC's per-field mutability flag, removes the value-versus-pointer distinction, and makes most types shareable across tasks without their author doing anything.

Diagnostics are the product

error[E0114]: cannot assign to immutable binding `total`
   ┌─ cart.kite:14:5
   │
 9 │     let total = 0
   │         ----- declared immutable here
   ⋮
14 │     total = total + item.price
   │     ^^^^^ cannot assign
   │
help: make the binding mutable
   │
 9 │     var total = 0
   │     ~~~

Several decisions in the language — nominal traits, explicit dyn, no implicit conversions, no overloading — were made because they let the compiler name one cause and one fix.