Cookbook

Read a File

import std.fs;

fn read_config(path: string) -> string {
    let content = std.fs.read_file(path);
    if content == nil {
        print("Failed to read: " + path);
        return "";
    }
    return content;
}

fn main() {
    let data = read_config("config.json");
    print(data);
}

Compute Average of Array

fn average(values: [float]) -> float {
    let n = values.length;
    if n == 0 {
        return 0.0;
    }
    let sum = 0.0;
    let i = 0;
    while i < n {
        sum = sum + values[i];
        i = i + 1;
    }
    return sum / n;
}

fn main() {
    let temps = [72.5, 68.3, 75.1, 70.0, 69.8];
    print(average(temps));  // 71.14
}

Define a Neural Network Layer

@layer struct Linear {
    @param weight = tensor_init(128, 64);
    @param bias = tensor_init(128);

    fn forward(self, x: tensor) -> tensor {
        return x @ self.weight + self.bias;
    }
}

@layer struct MLP {
    @param layer1 = Linear(64, 128);
    @param layer2 = Linear(128, 10);

    fn forward(self, x: tensor) -> tensor {
        let h = self.layer1.forward(x);
        let h = relu(h);
        return self.layer2.forward(h);
    }
}

fn main() {
    let model = MLP();
    let input = [[1.0, 0.5, ..., 0.0]];
    let output = model.forward(input);
    print(output);
}

Create a Diameter Logic Gate

diameter temperature: {
    pole hot: {
        return 80.0;
    }
    pole cold: {
        return 10.0;
    }
}

fn simulate() {
    let steps = 10;
    let i = 0;
    while i < steps {
        temperature.evolve();
        let tension = temperature.observe("tension");
        let state = temperature.observe("state");
        print("Step " + i + ": tension=" + tension);
        i = i + 1;
    }
}

fn main() {
    simulate();
}

Parse Command-Line Arguments

fn main() {
    let args = std.io.args();  // Returns array of strings
    let i = 0;
    while i < args.length {
        let arg = args[i];
        match arg {
            "--verbose" => print("Verbose mode on"),
            "--output" => {
                i = i + 1;
                let outfile = args[i];
                print("Output: " + outfile);
            },
            _ => print("Unknown: " + arg)
        }
        i = i + 1;
    }
}

Generate Random Numbers

extern fn srand(seed: int);
extern fn rand() -> int;

fn random_int(min: int, max: int) -> int {
    let r = rand();
    return min + (r % (max - min + 1));
}

fn main() {
    srand(42);
    let i = 0;
    while i < 5 {
        print(random_int(1, 100));
        i = i + 1;
    }
}

Sort an Array (Bubble Sort)

fn bubble_sort(arr: [int]) {
    let n = arr.length;
    let i = 0;
    while i < n {
        let j = 0;
        while j < n - i - 1 {
            if arr[j] > arr[j + 1] {
                let temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
            j = j + 1;
        }
        i = i + 1;
    }
}

fn main() {
    let nums = [64, 34, 25, 12, 22, 11, 90];
    bubble_sort(nums);
    print(nums);
}

Define a REST Endpoint (Junction)

import junction;

struct User {
    id: int;
    name: string;
    email: string;
}

fn handle_get_user(req: junction.Request) -> junction.Response {
    let user_id = req.params.id;
    let user = User {
        id: user_id,
        name: "Alice",
        email: "alice@example.com",
    };
    return junction.json(200, user);
}

fn main() {
    let app = junction.create_app({
        name: "my-api",
        version: "1.0.0",
    });
    app.get("/users/:id", handle_get_user);
    junction.serve(app, 8080);
}

Create a Frontend Component (Bond)

import bond;

struct Counter {
    count: int;
}

fn counter_view(state: Counter) -> bond.Element {
    return bond.div({ className: "counter" }, [
        bond.h1({}, ["Count: " + state.count]),
        bond.button({ onClick: fn() {
            state.count = state.count + 1;
            bond.render(counter_view(state));
        }}, ["+"]),
        bond.button({ onClick: fn() {
            state.count = state.count - 1;
            bond.render(counter_view(state));
        }}, ["-"]),
    ]);
}

fn main() {
    let app = bond.create_app(document.getElementById("root"));
    bond.render(counter_view(Counter { count: 0 }));
}

Train a Small Model

import std.train;
import std.models;

model tiny_llm = Transformer {
    vocab_size: 1024;
    d_model: 128;
    num_layers: 2;
    num_heads: 4;
    d_ff: 512;
    learning_rate: 0.001;
    batch_size: 4;
    seq_len: 64;
    num_epochs: 3;
}

fn main() {
    std.train.run(tiny_llm);
}

// Equivalent C-level API for fine-grained control:
// fn main() {
//     let cfg = TrainConfig {
//         d_model: 128, num_layers: 2,
//         vocab_size: 1024, batch_size: 4,
//         seq_len: 64, total_steps: 300,
//     };
//     train_cpu_only(cfg);
// }