Module kernel_api 

Sugar for writing kernels in Rust: Kernel + register_kernel, plus the safe KernelCtx / KernelContract wrappers.

This layer sits on top of the C ABI kernel vtable — the same thing include/lmflow/flow.hpp’s KernelAdapter<T> does for C++. It is not a native fast path that bypasses the vtable; its purpose is to make Rust a first-class language for writing kernels.

Implement Kernel, call register_kernel before Graph::from_yaml, then refer to the kernel by name from YAML as kernel: <name>.

use lmflow::packet::type_id;
use lmflow::{register_kernel, Kernel, KernelContract, KernelCtx, Packet};

#[derive(Default)]
struct Scale {
    factor: i64,
}

impl Kernel for Scale {
    fn get_contract(c: &mut KernelContract) {
        c.input_type(0, type_id::I64);
        c.output_type(0, type_id::I64);
    }

    fn open(&mut self, cc: &mut KernelCtx) -> lmflow::Result<()> {
        self.factor = cc.option_i64("factor", 2);
        Ok(())
    }

    fn process(&mut self, cc: &mut KernelCtx) -> lmflow::Result<()> {
        let v = cc
            .input(0)
            .and_then(|p| p.as_i64())
            .ok_or_else(|| cc.fail("input 0 must be an i64"))?;
        cc.emit(0, Packet::from_i64(v * self.factor))
    }
}

register_kernel::<Scale>("Scale")?;

Structs

KernelContract

The port-contract declaration handed to Kernel::get_contract — a safe wrapper around the internal Contract, valid only for the duration of that call.

KernelCtx

The context of one kernel callback — a safe wrapper around the internal Context.

Traits

Kernel

The interface for writing a kernel in Rust.

Functions

register_kernel

Register a Rust kernel under name.