How Hew Compares

actor Counter {
    let count: i32;
    receive fn increment(amount: i32) -> i32 {
        count = count + amount;
        count
    }
    receive fn get_count() -> i32 {
        count
    }
}
supervisor CounterPool {
    child counter: Counter
        restart(permanent)
        budget(5, 60s)
        strategy(one_for_one);
}
wire type CounterUpdate {
    counter_id: u32 @1;
    new_count: i32 @2;
    timestamp: u64 @3;
}
fn main() {
    let counter = spawn Counter(count: 0);
    counter.increment(10);
    let count = await counter.get_count();
    println(count);
}

package main

import (
    "fmt"
    "sync"
)

type Counter struct {
    mu    sync.Mutex
    count int32
}

func NewCounter() *Counter {
    return &Counter{}
}

func (c *Counter) Increment(amount int32) int32 {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count += amount
    return c.count
}

func (c *Counter) GetCount() int32 {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

// No built-in supervision. Manual restart logic.
type CounterPool struct {
    counters     []*Counter
    maxRestarts  int
    restartCount int
}

func NewCounterPool(size int) *CounterPool {
    pool := &CounterPool{
        counters:    make([]*Counter, size),
        maxRestarts: 5,
    }
    for i := range pool.counters {
        pool.counters[i] = NewCounter()
    }
    return pool
}

func (p *CounterPool) RestartChild(idx int) {
    p.restartCount++
    if p.restartCount > p.maxRestarts {
        fmt.Println("Exceeded restart limit")
        return
    }
    p.counters[idx] = NewCounter()
}

// No wire types. Plain struct with JSON tags.
type CounterUpdate struct {
    CounterID uint32 `json:"counter_id"`
    NewCount  int32  `json:"new_count"`
    Timestamp uint64 `json:"timestamp"`
}

func main() {
    counter := NewCounter()
    counter.Increment(10)
    fmt.Printf("count: %d\n", counter.GetCount())
}

use std::sync::{Arc, Mutex};

struct Counter {
    count: i32,
}

impl Counter {
    fn new() -> Self {
        Counter { count: 0 }
    }

    fn increment(&mut self, amount: i32) -> i32 {
        self.count += amount;
        self.count
    }

    fn get_count(&self) -> i32 {
        self.count
    }
}

type SharedCounter = Arc<Mutex<Counter>>;

fn new_shared_counter() -> SharedCounter {
    Arc::new(Mutex::new(Counter::new()))
}

fn shared_increment(counter: &SharedCounter, amount: i32) -> i32 {
    let mut c = counter.lock().unwrap();
    c.increment(amount)
}

// No built-in supervision. Manual restart logic.
struct CounterPool {
    counters: Vec<SharedCounter>,
    max_restarts: u32,
    restart_count: u32,
}

impl CounterPool {
    fn new(size: usize) -> Self {
        let counters = (0..size).map(|_| new_shared_counter()).collect();
        CounterPool {
            counters,
            max_restarts: 5,
            restart_count: 0,
        }
    }

    fn restart_child(&mut self, idx: usize) {
        self.restart_count += 1;
        if self.restart_count > self.max_restarts {
            eprintln!("Exceeded restart limit");
            return;
        }
        self.counters[idx] = new_shared_counter();
    }
}

// No wire types. Needs serde + a serialization crate.
// #[derive(Serialize, Deserialize)]
struct CounterUpdate {
    counter_id: u32,
    new_count: i32,
    timestamp: u64,
}

fn main() {
    let counter = new_shared_counter();
    let count = shared_increment(&counter, 10);
    println!("count: {}", count);
}