I build software close to the machine.

The interesting part is the boundary: move makes the owner change explicit.

struct Buffer {
    i32* data;
    i32 length;
}

impl Drop<Buffer> for Buffer {
    void drop(Buffer* self) {
        if (self.data != (i32*)0) {
            free(self.data);
            self.data = (i32*)0;
        }
    }
}

Buffer a;
a.init(32);
Buffer b = move a; // b owns the buffer now

Cleanup is attached to the scope and still runs before an early return.

i32 main() {
    i32 config = open("config");
    defer { close("config", config); }

    i32 pool = open("pool");
    defer { close("pool", pool); }

    return 0; // cleanup runs in LIFO order
}

A custom type can participate in for-in iteration without hidden allocation.

impl Iterator<Counter> for Counter {
    type Item = i32;

    Optional<i32> next(Counter* self) {
        if (self.current < self.end) {
            i32 value = self.current;
            self.current = self.current + 1;
            return Optional<i32>.some(value);
        }
        return Optional<i32>.none();
    }
}