Low-level control,
high-level code.

class Point {
    x : f64,
    y : f64,
    constructor(x : f64, y : f64) {
        self.x = x;
        self.y = y;
    }
    fn dist(self, other : Point) : f64 {
        let dx : f64 = self.x - other.x;
        let dy : f64 = self.y - other.y;
        return Math::sqrt(dx * dx + dy * dy);
    }
}

fn main() : i32 {
    let a : Point = new Point(0.0, 0.0);   // proven non-escaping
    let b : Point = new Point(3.0, 4.0);   // → plain stack slots
    Console::println(a.dist(b));           // 5.0
    return 0;                              // freed here — no malloc, no GC
}

fn count_primes(lo : i32, hi : i32) : i32 {
    let n = 0;
    for (x of lo..hi) {
        if (x < 2) { continue; }
        let prime = true;
        let d = 2;
        while (d * d <= x) {
            if (x % d == 0) { prime = false; break; }
            d = d + 1;
        }
        if (prime) { n = n + 1; }
    }
    return n;
}

fn main() : i32 {
    let jobs : Task<i32>[8];
    for (i of 0..8) {
        jobs[i] = spawn count_primes(i * 125000, (i + 1) * 125000);   // fan out
    }
    let total = 0;
    for (i of 0..8) {
        total = total + jobs[i].join();                               // fan in
    }
    return total;   // 78498 primes below 1,000,000
}

use std::net::HttpClient;

fn main() : i32 ! IOException {
    let body : string = HttpClient::get("https://example.com");
    Console::println(body);
    return 0;
}

@link_name("getpid")
native fn getpid() : i32;

fn main() : i32 {
    Console::println(getpid());
    return 0;
}

fn dot(a : f64[8], b : f64[8]) : f64 {
    let acc : f64x4 = f64x4.splat(0.0);
    acc = f64x4.load(a, 0).fma(f64x4.load(b, 0), acc);
    acc = f64x4.load(a, 4).fma(f64x4.load(b, 4), acc);
    return acc.sum();
}

use std::net::ServerSocket;
use std::net::Socket;

fn main() : i32 ! IOException {
    let srv : ServerSocket = new ServerSocket(8080);
    srv.bind();
    defer srv.close();
    let peer : Socket = srv.accept();
    defer peer.close();
    return 0;
}

trait Reader {
    fn read(self) : i32;
}

class Mem : Reader {
    v : i32,
    constructor(v : i32) {
        self.v = v;
    }
    fn read(self) : i32 {
        return self.v;
    }
}

class Const : Reader {
    constructor() {}
    fn read(self) : i32 {
        return 12;
    }
}

fn pull(r : dyn Reader) : i32 {   // dispatched at runtime from r's type
    return r.read();
}

fn main() : i32 {
    Console::println(pull(new Mem(30)) + pull(new Const()));   // 42
    return 0;
}

enum Shape {
    Circle(i32),
    Rect(i32, i32),
    Empty,
}

fn area(s : Shape) : i32 {
    return match s {                  // exhaustive — checked at compile time
        Shape::Circle(r) => r * r * 3,
        Shape::Rect(w, h) => w * h,
        Shape::Empty => 0,
    };
}

fn main() : i32 {
    Console::println(area(Shape::Rect(4, 5)));   // 20
    return 0;
}