The standard library

from std.prelude import unwrap_or, clamp, parse_int;

fn main() -> int {
    print(clamp(99, 0, 10));
    print(unwrap_or(parse_int("41"), 0) + 1);
    0
}

import std.option as opt;
import std.result as res;

fn main() -> int {
    let a = opt.map(Some(20), fn(x: int) -> x * 2);
    print(opt.unwrap_or(a, 0));
    print(opt.unwrap_or(None, 7));
    let r = res.map_err(Err("no"), fn(m: string) -> "error: " + m);
    match r { Ok(v) => print(v), Err(e) => print(e) };
    0
}

from std.stream import iota, emit_vec, collect;
from std.iter import zip;
from std.vec import of3;

fn main() -> int {
    let pairs = collect(zip(iota(10), emit_vec(of3("a", "b", "c"))));
    for (n, s) in pairs {
        print(s, n)
    }
    0
}

from std.vec import range_vec, map, filter, sum;

fn main() -> int {
    let squares = map(range_vec(1, 6), fn(x: int) -> x * x);
    print(sum(squares));
    let odds = filter(squares, fn(x: int) -> x % 2 == 1);
    print(len(odds));
    0
}

from std.sort import sort, binary_search;
from std.vec import of3;

fn main() -> int {
    let s = sort(of3(31, 4, 15));
    print(s[0], s[1], s[2]);
    match binary_search(s, 15) {
        Some(i) => print("found at", i),
        None => print("absent")
    };
    0
}

import std.map as map;

fn main() -> int {
    let @mut m = map.empty();
    map.put(m, "ada", 1815);
    map.put(m, "grace", 1906);
    map.put(m, "ada", 1816);
    print(map.size(m));
    match map.get(m, "ada") { Some(y) => print(y), None => print("absent") };
    print(map.get_or(m, "alan", 0));
    0
}

from std.string import repeat, reverse, join;
from std.vec import of3;

fn main() -> int {
    print(repeat("ab", 3));
    print(reverse("stressed"));
    print(join(of3("a", "b", "c"), ", "));
    0
}

from std.parse import parse_int, trim, split_on;

fn main() -> int {
    match parse_int(trim("  42 ")) { Some(n) => print(n), None => print("bad") };
    match parse_int("4x2") { Some(n) => print(n), None => print("bad") };
    print(len(split_on("3,14,15", ",")));
    0
}

from std.semver import parse_version, parse_requirement, range_contains,
    range_intersect, range_to_string;

fn main() -> int {
    match parse_requirement("^1.2") {
        None => print("bad requirement"),
        Some(r) => {
            print(range_to_string(r));
            match parse_version("1.5.0") {
                None => print("bad version"),
                Some(v) => print(range_contains(r, v))
            };
            match parse_version("2.0.0-rc.1") {
                None => print("bad version"),
                Some(v) => print(range_contains(r, v))
            };
            match parse_requirement(">=1.5, <3") {
                None => print("bad requirement"),
                Some(other) => print(range_to_string(range_intersect(r, other)))
            }
        }
    };
    0
}

from std.semver import version, parse_requirement, range_any, version_to_string;
from std.solve import graph_new, graph_add, dep, solve;

fn req(name: string, text: string) -> Dep {
    match parse_requirement(text) { None => dep(name, range_any()), Some(r) => dep(name, r) }
}

fn main() -> int {
    let @mut g = graph_new();
    let @mut foo10 = Vec.new();
    foo10.push(req("bar", "^1"));
    graph_add(g, "foo", version(1, 0, 0), foo10);
    let @mut foo11 = Vec.new();
    foo11.push(req("bar", "^2"));
    graph_add(g, "foo", version(1, 1, 0), foo11);
    graph_add(g, "bar", version(1, 0, 0), Vec.new());
    graph_add(g, "bar", version(2, 0, 0), Vec.new());
    let @mut root = Vec.new();
    root.push(req("foo", "^1"));
    root.push(req("bar", "^1"));
    graph_add(g, "app", version(0, 1, 0), root);
    let out = solve(g, "app", version(0, 1, 0), Vec.new(), Vec.new());
    print(out.ok);
    let @mut i = 0;
    while i < len(out.names) {
        print(out.names[i] + " " + version_to_string(out.versions[i]));
        i = i + 1
    }
    0
}

from std.hex import to_hex, from_hex;
from std.sha256 import sha256_hex, sha256_string;

fn main() -> int {
    print(sha256_string(""));
    match from_hex("616263") {
        None => print("bad hex"),
        Some(bytes) => {
            print(bytes.from_bytes());
            print(sha256_hex(bytes) == sha256_string("abc"));
            print(to_hex(bytes))
        }
    };
    match from_hex("6x") { None => print("bad hex"), Some(b) => print(len(b)) };
    0
}

from std.path import join, normalize, relpath;
from std.json import Json, member, to_json;
from std.toml import Toml, parse, to_toml, get_table, get_str;

fn main() -> int {
    print(normalize(join("pkgs/geom", "../util/./src")));
    print(relpath("/work/app/vendor/geom", "/work/app"));
    let @mut fields = Vec.new();
    fields.push(member("name", JStr("app")));
    fields.push(member("deps", JArr(Vec.new())));
    print(to_json(JObj(fields)));
    match parse("[package]\nname = \"app\"\n\n[dependencies]\ngeom = { git = \"https://x/geom\", rev = \"v1\" }\n") {
        Err(e) => print(e),
        Ok(doc) => {
            match get_table(doc, "package") {
                None => print("no package table"),
                Some(pkg) => match get_str(pkg, "name") {
                    None => print("no name"),
                    Some(name) => print(name)
                }
            };
            print(to_toml(doc))
        }
    };
    match parse("version = 1.5\n") { Err(e) => print(e), Ok(doc) => print("parsed") };
    0
}

from std.fs import Fs, read_text, write_text, exists;
from std.process import Process, output_of;

fn index_of(names: Vec, name: string) -> int {
    let @mut i = 0;
    let @mut found = 0 - 1;
    while i < len(names) && found < 0 {
        if names[i] == name { found = i } else { () };
        i = i + 1
    }
    found
}

fn main() -> int {
    let @mut names = Vec.new();
    let @mut bodies = Vec.new();
    handle Fs with {
        write_bytes(path, bytes) -> {
            let k = index_of(names, path);
            if k < 0 { names.push(path); bodies.push(bytes) } else { bodies[k] = bytes };
            resume(())
        },
        read_bytes(path) -> {
            let k = index_of(names, path);
            if k < 0 { raise("virtual read: " + path + " was never written") } else { resume(bodies[k]) }
        },
        exists(path) -> resume(index_of(names, path) >= 0)
    } in {
        write_text("mx.toml", "[package]\nname = \"app\"");
        print(read_text("mx.toml"));
        print(exists("mx.lock"));
        if exists("mx.lock") { print(read_text("mx.lock")) } else { print("no lock yet") }
    };
    let @mut git = Vec.new();
    git.push("git");
    git.push("rev-parse");
    git.push("HEAD");
    handle Process with {
        run(argv, cwd) -> resume(1),
        status(h) -> resume(0),
        stdout(h) -> resume("0123abcd\n"),
        stderr(h) -> resume("")
    } in {
        match output_of(git, "") { Ok(t) => print("fake git said " + t.trim()), Err(e) => print(e) }
    };
    0
}

from std.math import pi, abs, sqrt, powi;

fn main() -> int {
    print(pi);
    print(abs(-7));
    print(sqrt(9));
    print(powi(2, 10));
    0
}

from std.random import Random, with_seed, next_below;

fn main() -> int {
    with_seed(7, fn() -> () {
        print(next_below(100), next_below(100), next_below(100));
        ()
    });
    0
}

from std.state import State, run_state, modify, increment;

fn step() performs State -> () {
    increment(5);
    modify(fn(s: int) -> s * 2);
    ()
}

fn main() -> int {
    let r = run_state(10, fn() -> () { step() });
    print(r.state);
    0
}

from std.log import Log, log_info, log_warn, with_collected_logs;

fn work() -> () {
    log_info("starting");
    log_warn("low disk");
    ()
}

fn main() -> int {
    work();                 # unhandled: the defaults print
    let lines = with_collected_logs(fn() -> () { work() });
    print("collected", len(lines));
    0
}

from std.test import assert_eq, run_tests;

fn main() -> int {
    let report = run_tests("suite", fn() -> () {
        assert_eq(1 + 1, 2, "arithmetic");
        assert_eq(len("abc"), 3, "len");
        ()
    });
    print(report.total, "run,", report.failed, "failed");
    report.failed
}