From Rust

You trust the borrow checker but you are tired of negotiating with it over self-referential structs, and tired of pinning CPU cores for minutes per build. Rasmalai keeps deterministic memory and drops both taxes. Your ownership mental model transfers almost untouched — the annotations stay behind.

Lifetimes vs lexical scopes

Rust names every borrow. Rasmalai ties each value to the block that owns it — the scope end is the free point, visible in the source:

Shared structure that would cycle in Rust uses GenRef<T> handles here: copying one never touches atomics, and .get() yields null once the owner frees. No annotations, no borrowck fight.

struct Edge {
    let label: String;
    let weight: Int;
}

let edges = [Edge("ore", 0), Edge("ore", 2)];
let total = 0;
for e in edges {
    total = total + e.weight;
}
print(total);

Drop vs defer

Rust runs Drop::drop at scope end. Rasmalai runs defer blocks at scope end, in the open, in order:

Output order is query ran, txn committed, conn closed: last-in, first-out, exactly like stacked guards.

defer { print("conn closed"); }
defer { print("txn committed"); }
print("query ran");

Result vs throws

Throwing functions mark throws; callers use try or propagate with their own throws. Caught values dispatch with switch and is checks instead of combinator chains:

fn risky(ok: Bool): Int throws {
    if ok { return 1; }
    throw 0;
}

try {
    print(risky(true));
} catch (err) {
    print("failed");
}

What changes, what stays

Keep your mental model of ownership. Lose the wait. Next: the Guide from the top, or the Manual for exact ARC semantics.