Safety is the default.

struct Point {
    x: int,
    y: int
}

impl Point {
    fn dist2(self: Point) -> int {
        return self.x * self.x + self.y * self.y
    }
    fn translate(mut self: Point, dx: int) -> void {
        self.x = self.x + dx
    }
}

fn main() -> int uses IO {
    let p: Point = Point { x: 3, y: 4 }
    p.translate(1)
    println("dist2 = " + p.dist2().to_str())
    return 0
}

fn read_config(path: str) -> str uses Fs {
    return read_file(path)
}

fn elapsed_ms() -> int uses Clock {
    return clock_ms()
}

fn pure_compute(n: int) -> int {
    # No `uses` clause -> pure by construction.
    let mut s: int = 0
    let mut i: int = 0
    while i < n {
        s = s + i
        i = i + 1
    }
    return s
}

fn main() -> int uses IO {
    let n: int = pure_compute(10)
    println("sum(0..10) = " + n.to_str())
    return 0
}

import "std.sanitize"

fn main() -> int uses Args, IO {
    # Every argv arrives tainted by default.
    let argv: list[tainted[str]] = tainted_args()

    if argv.len() > 1 {
        # println is a sink: tainted data cannot reach it.
        println("hello, " + sanitize_filename(argv.get(1)))
    }
    return 0
}

fn fib(n: int) -> int {
    if n < 2 {
        return n
    }
    return fib(n - 1) + fib(n - 2)
}

fn worker(job: int, req: Chan[int], rep: Chan[int]) -> int uses Conc {
    let answer: int = fib(job)
    rep.send(answer)
    return req.recv()
}

fn main() -> int uses IO, Conc {
    let t: Task[int] = spawn(fib, 25)
    let r: int = t.join()
    println("fib(25) = " + r.to_str())

    let req: Chan[int] = chan_new()
    let rep: Chan[int] = chan_new()
    let w: Task[int] = spawn(worker, 20, clone(req), clone(rep))
    req.send(0)
    let answer: int = rep.recv()
    return 0
}