Struct HostRegistry 

pub struct HostRegistry { /* private fields */ }

The table of Rust closures a script’s host blocks bind to.

Both halves of the toolchain bind through this one table. The candela crate’s Engine binds at compile time, against the host signatures a fresh compile produced; crate::artifact::load_program binds at load time, against the signatures a .cdlb recorded. The checks are the same in both cases, so an artifact that loads is bound as strictly as a script that compiles.

Implementations

impl HostRegistry

pub fn new() -> HostRegistry

pub fn register_host_fn<Marker, F>(&mut self, namespace: &str, name: &str, f: F)

where F: IntoHostFn<Marker>,

Registers a typed host function under namespace::name.

The closure may take any combination of i64/i32, f64, bool, String (or a single &str), Vec<T> and string-keyed map arguments, and return one of those or (). A closure that can fail returns Result<T, HostError> instead, and the error is raised in the script that called it. The derived types are checked against the host block when the script is bound; a mismatch is an error, never a panic.

pub fn register_host_fn_typed<F>( &mut self, namespace: &str, name: &str, arg_types: Vec<HostType>, ret_type: HostType, f: F, )

where F: Fn(&[Value]) -> Result<Value, HostError> + 'static,

Registers a host function whose signature is given as data.

The closure takes the arguments as a &[Value] slice, as a variadic one does, but arg_types and ret_type pin the signature, so the binding is checked against the host block exactly as register_host_fn is and the declaration must not use .... This is what a host registers through when the signature is only known at run time: a plugin table, a generated binding, anything with no Rust type to derive it from.

pub fn register_host_fn_variadic<F>( &mut self, namespace: &str, name: &str, f: F, )

where F: Fn(&[Value]) -> Result<Value, HostError> + 'static,

Registers a variadic host function under namespace::name.

The closure receives every argument as a &[Value] slice of any length and returns one Value, or a HostError to raise in the script that called it, so arguments of mixed or dynamically-typed shape cross the boundary without a fixed Rust signature. The host block must declare the function with a ... argument list, and no arity or per-argument type checking happens at the call site.

pub fn bind( &self, sigs: &[HostFnSig], structs: &[Struct], ) -> Result<Vec<Rc<dyn Fn(&[Value]) -> Result<Value, HostError>>>, HostBindError>

Binds every declared host signature to its registered closure, returning the dispatchers in host-function id order.

Errors

Returns HostBindError::Unregistered naming every declared function with no closure behind it, or HostBindError::SignatureMismatch for the first closure whose arity or types disagree with the declaration.

Trait Implementations

impl Default for HostRegistry

fn default() -> HostRegistry

Returns the “default value” for a type.