patterns

Sounio Patterns — Verified Copy-Paste Examples

All patterns are sourced from tests/run-pass/ and verified with souc check.

Hello World

fn main() with IO {
    println("Hello, World!")
}

Array Processing (map/fold)

fn square(x: i64) -> i64 { x * x }

fn map4(arr: [i64; 4], f: fn(i64) -> i64) -> [i64; 4] with Mut, Panic {
    var out: [i64; 4] = [0; 4]
    var i: i64 = 0
    while i < 4 {
        out[i as usize] = f(arr[i as usize])
        i = i + 1
    }
    out
}

fn fold4(arr: [i64; 4], init: i64, f: fn(i64, i64) -> i64) -> i64 with Panic {
    var acc = init
    for i in 0..4 {
        acc = f(acc, arr[i as usize])
    }
    acc
}

Error Handling (Tuples)

fn safe_divide(a: f64, b: f64) -> (f64, i32) with Div, Panic {
    if b == 0.0 { (0.0, 1) }    // error code 1
    else { (a / b, 0) }          // success
}

fn main() with IO, Div, Panic {
    let (result, err) = safe_divide(10.0, 3.0)
    if err == 0 { println("OK") }
    else { println("Division by zero") }
}

Struct with Methods

struct Counter { value: i64 }

impl Counter {
    fn new() -> Counter { Counter { value: 0 } }
    fn get(self: &Counter) -> i64 { self.value }
    fn increment(self: &!Counter) with Mut { self.value = self.value + 1 }
}

fn main() with IO, Mut {
    var c = Counter::new()
    c.increment()
    c.increment()
    assert(c.get() == 2)
}

Array Mutation via &! Reference

// Use explicit deref for bare arrays
fn fill(arr: &![i64; 4], val: i64) with Mut, Panic {
    (*arr)[0] = val
    (*arr)[1] = val
    (*arr)[2] = val
    (*arr)[3] = val
}

// Or wrap in struct (more reliable)
struct Buffer { data: [i64; 256] }

fn fill_buffer(buf: &!Buffer, val: i64) with Mut, Panic {
    for i in 0..256 {
        buf.data[i as usize] = val
    }
}

Higher-Order Functions

fn double(x: i64) -> i64 { x + x }
fn negate(x: i64) -> i64 { 0 - x }

fn select_op(which: i64) -> fn(i64) -> i64 {
    if which == 0 { double }
    else { negate }
}

fn main() with IO, Panic {
    let op = select_op(0)
    let result = op(21)
    assert(result == 42)
}