vihaco

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

// Bytecode-visible operations. Each variant becomes an opcode; tuple fields
// become the payload bytes that follow it.
component! {
    #[derive(Debug, Default)]
    pub component Counter {
        value: i64,
    }

    instruction {
        Add(i64),
        Print,
    }
}

use counter::runtime::Instruction as CounterInst;

/// 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);

// One `execute` per component: (instruction, message) in, effects out.
#[dispatch(instruction = counter::runtime::Instruction, message = Prefix, effect = Line)]
impl counter::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.