vihaco

use eyre::Result;
use vihaco::{Effects, Instruction, Message, component};

/// Bytecode-visible operations. Each variant becomes an opcode; tuple
/// fields become the payload bytes that follow it.
#[derive(Debug, Clone, Instruction)]
pub enum CounterInst {
    Add(i64),
    Print,
}

/// Resolved execution input — supplied by the runtime, not encoded in
/// the instruction stream.
#[derive(Debug, Clone, Message)]
pub struct Prefix(pub String);

/// A value the component returns for the runtime or observers to consume.
#[derive(Debug, Clone, PartialEq)]
pub struct Line(pub String);

#[derive(Debug, Default)]
pub struct Counter {
    value: i64,
}

// One `execute` per component: (instruction, message) in, effects out.
#[component(instruction = CounterInst, message = Prefix, effect = Line)]
impl Counter {
    fn execute(&mut self, inst: CounterInst, msg: Prefix) -> Result<Effects<Line>> {
        match inst {
            CounterInst::Add(v) => {
                self.value += v;
                Ok(Effects::none())
            }
            CounterInst::Print => Ok(Effects::one(Line(format!("{}{}", msg.0, self.value)))),
        }
    }
}

A component is an execution unit: it takes a typed instruction plus a resolved message and returns typed effects. The derives handle opcodes, encoding, and the runtime glue.

use eyre::Result;
use vihaco::{Effects, observe};

#[derive(Debug, Clone)]
pub struct Line(pub String);

/// A standalone observer: it reacts to delivered effects and owns no
/// instructions or messages of its own.
#[derive(Debug, Default)]
pub struct Collector {
    lines: Vec<String>,
}

// `#[observe(T)]` generates `Observe<T>`; the handler is named
// `observe_<snake_case_effect>` and may return follow-up effects.
#[observe(Line)]
impl Collector {
    fn observe_line(&mut self, effect: &Line) -> Result<Effects<()>> {
        self.lines.push(effect.0.clone());
        Ok(Effects::none())
    }
}

Execution and effect delivery are separate. Anything can #[observe] an effect type — a log sink, a recorder, or another component reacting to what its neighbours produced.