具体的なHewプログラム

現在のコンパイラとプレイグラウンドが扱える内容を示す、焦点を絞った小さなプログラムから始めてください：基本的な関数、アクター、スーパービジョン構文、ワイヤースキーマ。

基礎

Hello World

最小の完全なHewプログラム：1つのエントリポイントと1行の出力。

hello_world.hew

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

基礎

Fibonacci

再帰関数、整数制御フロー、範囲、フォーマット出力。

プレイグラウンドで開く

fibonacci.hew

fn fib(n: i64) -> i64 {
    if n <= 1 {
        n
    } else {
        fib(n - 1) + fib(n - 2)
    }
}
 
fn main() {
    for i in 0 .. 10 {
        println(f"fib({i}) = {fib(i)}");
    }
}

アクター

Counter Actor

ローカルアクターが状態を所有し、型付きreceiveメソッドで更新する。

プレイグラウンドで開く

counter_actor.hew

actor Counter {
    var count: i64;
    receive fn increment(n: i64) -> i64 {
        count = count + n;
        println(f"Count is now: {count}");
        count
    }
}
 
fn main() {
    let c = spawn Counter { count: 0 };
    // Each call waits for its handler; expect reports a failed call.
    c.increment(5).expect("counter stopped");
    c.increment(3).expect("counter stopped");
    let total = match c.increment(12) {
        .Ok(v) => v,
        .Err(_) => -1,
    };
    println(f"Final total: {total}");
}

アクター

Actor Pipeline

アクターをスポーンしてmainからのメッセージ呼び出しのシーケンスを待機する。

プレイグラウンドで開く

actor_pipeline.hew

actor Doubler {
    receive fn process(n: i64) -> i64 {
        let result = n * 2;
        println(f"Result: {result}");
        result
    }
}
 
fn main() {
    let doubler = spawn Doubler;
    let a = match doubler.process(5) {
        .Ok(v) => v,
        .Err(_) => -1,
    };
    let b = match doubler.process(21) {
        .Ok(v) => v,
        .Err(_) => -1,
    };
    let c = match doubler.process(100) {
        .Ok(v) => v,
        .Err(_) => -1,
    };
    println(f"got {a}, {b}, {c}");
}

スーパービジョン

Supervisor

再起動戦略、再起動バジェット、名前付き子を持つ小さな監視ツリー。

プレイグラウンドで開く

supervisor.hew

actor Worker {
    let id: i64;
    receive fn work(x: i64) -> i64 {
        println(f"Worker {id} processing {x}");
        x
    }
}
 
supervisor WorkerPool {
    strategy: one_for_one;
    intensity: 5 within 10s;
 
    child w1: Worker { id: 1 };
    child w2: Worker { id: 2 };
}
 
fn main() {
    let workers = spawn WorkerPool;
    // Access supervised children by their declared names.
    let w1 = workers.w1;
    let w2 = workers.w2;
    let a = match w1.work(10) {
        .Ok(v) => v,
        .Err(_) => -1,
    };
    let b = match w2.work(20) {
        .Ok(v) => v,
        .Err(_) => -1,
    };
    println(f"w1 -> {a}");
    println(f"w2 -> {b}");
}
// After both replies, the program exits and its supervised workers stop.

プロトコル

Wire Types

明示的なシリアライゼーションスキーマのためのタグ付きワイヤーstructとenum。

プレイグラウンドで開く

wire_types.hew

// Wire types are schema-checked serialization contracts. Each field carries
// an explicit tag (@1, @2, ...) so the binary encoding stays compatible as
// the schema evolves. Optional fields may be added or omitted across versions.
#[wire]
type UserMessage {
    name: string @1;
    age: i32 @2;
    nickname: Option<string> @3 optional;
}
 
fn main() {
    println("Wire types define serialization schemas.");
    println("Fields have explicit tags (@1, @2) for");
    println("backwards-compatible binary encoding.");
}