Low-level control,
high-level code.

class Point {
    x : f64,
    y : f64,

    constructor(x : f64, y : f64) {
        self.x = x;
        self.y = y;
    }

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

fn main() : i32 {
    let a : Point = new Point(0.0, 0.0);   // proven non-escaping
    let b : Point = new Point(3.0, 4.0);   // → stack slots
    Console::println(a.dist(b));           // 5.0

    // Freed here — no malloc, no GC.
    return 0;
}

/** Sum of squares over a half-open range. */
fn squares(lo : i32, hi : i32) : i64 {
    let acc : i64 = 0;
    for (x of lo..hi) {
        acc = acc + (x as i64) * (x as i64);
    }
    return acc;
}

fn main() : i32 {
    let jobs : Future<i64>[4];
    for (i of 0..4) {
        // Fan out — one job per quarter of the range.
        jobs[i] = spawn squares(i * 250000, (i + 1) * 250000);
    }

    let total : i64 = 0;
    for (i of 0..4) {
        // Fan in, in order.
        total = total + await jobs[i];
    }

    Console::println(total);
    return 0;
}

use std::net::HttpClient;
use std::text::json::jsonValidate;

fn main() : i32 {
    let http = new HttpClient();
    try {
        let url = "https://api.github.com/repos/axle-lang/axle";
        let body = http.get(url).body();
        if (!jsonValidate(body)) {
            Console::println("not JSON");
            return 1;
        }
        Console::println("ok, " + body.length + " bytes");
    } catch e : IOException {
        // `get` declares `! IOException`. Not optional.
        Console::println("fetch failed: " + e.message);
        return 1;
    }
    return 0;
}

extern "C" from "c" {
    fn qsort(base : ptr, n : i64, size : i64,
             cmp : extern "C" (ptr, ptr) => i32) : void;
}

/** The comparator C calls back into — one machine word. */
fn ascending(a : ptr, b : ptr) : i32 {
    unsafe {
        let pa : ptr<i32> = a as ptr<i32>;
        let pb : ptr<i32> = b as ptr<i32>;
        if (*pa < *pb) { return 0 - 1; }
        if (*pa > *pb) { return 1; }
        return 0;
    }
}

fn main() : i32 {
    let xs : i32[5] = [42, 7, 19, 3, 25];

    unsafe {
        // A named fn captures nothing and throws nothing, so it
        // degrades to the one-word pointer C's argument wants.
        qsort((&xs[0]) as ptr, 5, sizeof<i32>(), ascending);
    }

    Console::println(xs[0]);   // 3 — C sorted it in place
    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, Socket};

/** Read one request and answer it. An error ends this peer. */
fn serve(peer : Socket) : void {
    try {
        let req = peer.getInputStream().readString(1024);
        let out = peer.getOutputStream();
        out.writeString("HTTP/1.1 200 OK\r\n");
        out.writeString("Content-Length: 3\r\n\r\nhi\n");
        out.flush();
    } catch e : IOException {
        Console::println("peer dropped: " + e.message);
    }
    try {
        peer.close();
    } catch e : IOException {
        // Already gone: nothing left to release.
    }
}

fn main() : i32 {
    try {
        let srv = new ServerSocket(8080);
        srv.bind();
        defer srv.close();
        Console::println("listening on " + srv.getLocalPort());
        for (i of 0..3) {
            serve(srv.accept());
        }
    } catch e : IOException {
        Console::println("cannot listen: " + e.message);
        return 1;
    }
    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;
    }
}

// Dispatched at runtime, off r's own type header.
fn pull(r : dyn Reader) : i32 {
    return r.read();
}

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

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

fn area(s : Shape) : i32 {
    // Exhaustive — checked at compile time.
    return match s {
        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;
}