Language Specification

import std.net;
 
pub type Packet {
    id: u64;
    payload: Vec<u8>;
    ttl: u8;
}

import std.math;
 
const DEFAULT_LIMIT: i64 = 100;
 
type Point { x: f64; y: f64; }
 
enum Shape {
    Circle(f64);
    Rectangle { width: f64; height: f64; }
    Unit;
}
 
fn distance(a: Point, b: Point) -> f64 {
    math.sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y))
}
 
fn describe(id: u64) -> string {
    f"user-{id}"
}
 
gen fn ids() -> i64 {
    var next: i64 = 0;
    loop {
        yield next;
        next += 1;
    }
}

trait Summary {
    fn summarize(it: Self) -> string;
}
 
type Article {
    title: string;
    body: string;
}
 
impl Summary for Article {
    fn summarize(it: Article) -> string {
        f"{it.title}: {it.body}"
    }
}

import std.iter;
 
actor Cache {
    receive fn lookup(key: string) -> string { "" }
}
 
// A select deadline can bound an ordinary actor call.
actor Client {
    let cache: Cache;
 
    receive fn fetch(key: string) -> string {
        select {
            reply from cache.lookup(key) => reply handle e { "unavailable" },
            after 500ms => "timeout",
        }
    }
}
 
fn main() {
    let numbers: Vec<i64> = Vec.new();
    let doubled = iter.map(numbers.into_iter(), |n: i64| n * 2);
    let result: Vec<i64> = iter.collect(doubled);
    _ = result;
 
    let worker = actor |msg: string| {
        println(f"received {msg}");
    };
    worker("hello").expect("worker stopped");
    stop(worker);
    stopped(worker);
}

type Item { done: bool; }
 
fn main() {
    let count = 0;
    let label = if count == 0 { "empty" } else { "ready" };
    _ = label;
 
    let items: Vec<Item> = [Item { done: true }];
    var found: Option<Item> = .None;
    @scan: for item in items {
        if item.done {
            found = .Some(item);
            break @scan;
        }
    }
    println(found.is_some());
}
 
enum IoError { NotFound; }
 
fn with_file(_path: string) -> Result<string, IoError> {
    // defer runs exactly once at scope exit
    defer {
        // cleanup here
    };
    Result.Err(IoError.NotFound)
}

fn use_val(v: i64) { println(v); }
type Point { x: f64; y: f64; }
 
fn main() {
    let result: Result<Option<i64>, string> = Result.Ok(Option.Some(42));
    match result {
        .Ok(.Some(value)) => use_val(value),
        .Ok(.None) => println("empty"),
        .Err(e) => println(f"error: {e}"),
    }
 
    let cursor = Point { x: 1.0, y: 2.0 };
    let Point { x, y } = cursor;
    println(f"{x} {y}");
}

actor Counter {
    var count: i64 = 0;
    mailbox 256 overflow block;
 
    receive fn increment(n: i64) {
        count += n;
    }
 
    receive fn get() -> i64 {
        count
    }
}
 
fn main() {
    let counter = spawn Counter { count: 0 };
    counter.increment(10).expect("actor stopped");
    match counter.get() {
        .Ok(current) => println(current),
        .Err(_) => println("ask failed"),
    }
}

actor DatabaseActor {
    var shard: i64 = 0;
    receive fn query(sql: string) -> string { "" }
}
actor CacheActor {
    var capacity: i64 = 0;
    receive fn get(key: string) -> string { "" }
}
actor MetricsActor {
    var port: i64 = 0;
    receive fn emit(name: string) { println(name); }
}
 
supervisor AppSupervisor {
    strategy: one_for_one;
    intensity: 5 within 30s;
 
    child db:      DatabaseActor { shard: 1 }      restart: permanent;
    child cache:   CacheActor { capacity: 1024 }   restart: transient;
    child metrics: MetricsActor { port: 9090 }     restart: temporary;
}

fn load_user(id: u64) { println(f"user-{id}"); }
fn load_posts(id: u64) { println(f"posts-{id}"); }
 
actor Cache  { receive fn get(key: string) -> string { "" } }
actor Origin { receive fn get(key: string) -> string { "" } }
 
actor ProfileService { receive fn profile(id: u64) -> string { "" } }
actor StatsService   { receive fn stats(id: u64)   -> string { "" } }
 
// scope + fork: parallel tasks inside an actor handler
actor Service {
    receive fn handle(id: u64) {
        scope {
            let user_t = fork load_user(id);
            let posts_t = fork load_posts(id);
            await user_t;
            await posts_t;
        }
    }
}
 
// select: race actor replies against a timeout (inside an actor handler)
actor Resolver {
    let cache:  Cache;
    let origin: Origin;
 
    receive fn resolve(key: string) -> string {
        let key2 = key.clone();
        let chosen = select {
            cached from cache.get(key)   => cached handle e { "unavailable" },
            fresh  from origin.get(key2) => fresh handle e { "unavailable" },
            after 100ms                  => "fallback",
        };
        chosen
    }
}
 
// join: wait for all branches (inside an actor handler)
actor Aggregator {
    let profile_svc: ProfileService;
    let stats_svc:   StatsService;
 
    receive fn aggregate(id: u64) {
        let (profile, stats) = await fork (
            profile_svc.profile(id),
            stats_svc.stats(id),
        );
        println(f"{profile.expect("profile service stopped")} {stats.expect("stats service stopped")}");
    }
}

machine Connection {
    events {
        Connect { peer: string; }
        Disconnect;
    }
 
    state Closed;
    state Open { peer: string; }
 
    on Connect: Closed => Open when event.peer.len() > 0 { peer: event.peer }
    on Disconnect: Open => Closed ;
 
    default { state }
}

#[wire]
#[serial(case = "camelCase")]
type User {
    name: string @1;
    email: string @2;
    age: Option<u32> @3 optional;
    role: i32 @4 since 2;
    #[serial(key = "id")]
    user_id: u64 @5;
    reserved @6, @7;
}

extern "C" {
    fn malloc(size: usize) -> *mut u8;
    fn free(ptr: *mut u8);
    fn printf(fmt: *const u8 ..) -> i32;
}
 
fn allocate(size: usize) -> *mut u8 {
    unsafe { malloc(size) }
}

fn main() {
    let dec = 1_000_000;
    let hex = 0xFF;
    let oct = 0o755;
    let bin = 0b1010;
    let timeout: duration = 500ms;
    let raw = r"no escapes here";
    let bytes = b"hello";
    let newline = '
';
    let count = 42;
    let message = f"count is {count + 1}";
    let byte_count = bytes.len();
    _ = (dec, hex, oct, bin, timeout, raw, byte_count, newline, message);
}