Struct rhai::Engine

pub struct Engine {
    pub fns: HashMap<FnSpec, Arc<FnIntExt>>,
}

Rhai's engine type. This is what you use to run Rhai scripts

extern crate rhai;
use rhai::Engine;

fn main() {
    let mut engine = Engine::new();

    if let Ok(result) = engine.eval::<i64>("40 + 2") {
        println!("Answer: {}", result);  // prints 42
    }
}

Fields

fns: HashMap<FnSpec, Arc<FnIntExt>>

A hashmap containing all functions known to the engine

Methods

impl Engine

pub fn call_fn<'a, I, A, T>(
    &self,
    ident: I,
    args: A
) -> Result<T, EvalAltResult> where
    I: Into<String>,
    A: FunArgs<'a>,
    T: Any + Clone, 

pub fn call_fn_raw(
    &self,
    ident: String,
    args: Vec<&mut Any>
) -> Result<Box<Any>, EvalAltResult>

Universal method for calling functions, that are either registered with the Engine or written in Rhai

pub fn register_fn_raw(
    &mut self,
    ident: String,
    args: Option<Vec<TypeId>>,
    f: Box<Fn(Vec<&mut Any>) -> Result<Box<Any>, EvalAltResult>>
)

pub fn register_type<T: Any>(&mut self)

Register a type for use with Engine. Keep in mind that your type must implement Clone.

pub fn register_get<T: Clone + Any, U: Clone + Any, F>(
    &mut self,
    name: &str,
    get_fn: F
) where
    F: 'static + Fn(&mut T) -> U, 

Register a get function for a member of a registered type

pub fn register_set<T: Clone + Any, U: Clone + Any, F>(
    &mut self,
    name: &str,
    set_fn: F
) where
    F: 'static + Fn(&mut T, U), 

Register a set function for a member of a registered type

pub fn register_get_set<T: Clone + Any, U: Clone + Any, F, G>(
    &mut self,
    name: &str,
    get_fn: F,
    set_fn: G
) where
    F: 'static + Fn(&mut T) -> U,
    G: 'static + Fn(&mut T, U), 

Shorthand for registering both getters and setters

pub fn eval_file<T: Any + Clone>(
    &mut self,
    fname: &str
) -> Result<T, EvalAltResult>

Evaluate a file

pub fn eval<T: Any + Clone>(&mut self, input: &str) -> Result<T, EvalAltResult>

Evaluate a string

pub fn eval_with_scope<T: Any + Clone>(
    &mut self,
    scope: &mut Scope,
    input: &str
) -> Result<T, EvalAltResult>

Evaluate with own scope

pub fn consume_file(&mut self, fname: &str) -> Result<(), EvalAltResult>

Evaluate a file, but only return errors, if there are any. Useful for when you don't need the result, but still need to keep track of possible errors

pub fn consume(&mut self, input: &str) -> Result<(), EvalAltResult>

Evaluate a string, but only return errors, if there are any. Useful for when you don't need the result, but still need to keep track of possible errors

pub fn consume_with_scope(
    &mut self,
    scope: &mut Scope,
    input: &str
) -> Result<(), EvalAltResult>

Evaluate a string with own scoppe, but only return errors, if there are any. Useful for when you don't need the result, but still need to keep track of possible errors

pub fn register_default_lib(engine: &mut Engine)

Register the default library. That means, numberic types, char, bool String, arithmetics and string concatenations.

pub fn new() -> Engine

Make a new engine

Trait Implementations

impl Clone for Engine

fn clone(&self) -> Engine

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    A: Any + Clone,
    B: Any + Clone,
    C: Any + Clone,
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<A>, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    A: Any + Clone,
    B: Any + Clone,
    C: Any + Clone,
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<A>, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    A: Any + Clone,
    B: Any + Clone,
    C: Any + Clone,
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    B: Any + Clone,
    C: Any + Clone,
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<B>, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    B: Any + Clone,
    C: Any + Clone,
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<B>, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    B: Any + Clone,
    C: Any + Clone,
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    C: Any + Clone,
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<C>, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    C: Any + Clone,
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<C>, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    C: Any + Clone,
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<D>, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<D>, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    D: Any + Clone,
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<E>, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<E>, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    E: Any + Clone,
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (F, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<F>, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<F, G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<F>, G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    F: Any + Clone,
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut F, G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (G, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<G>, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<G, H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<G>, H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    G: Any + Clone,
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut G, H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (H, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<H>, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<H, I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<H>, I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    H: Any + Clone,
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut H, I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (I, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<I>, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<I, J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<I>, J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    I: Any + Clone,
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut I, J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (J, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<J>, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<J, K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<J>, K, L, M, N, O, P, Q, R, S), RET> for Engine where
    J: Any + Clone,
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut J, K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (K, L, M, N, O, P, Q, R, S), RET> for Engine where
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<K>, L, M, N, O, P, Q, R, S), RET> for Engine where
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<K, L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<K>, L, M, N, O, P, Q, R, S), RET> for Engine where
    K: Any + Clone,
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut K, L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (L, M, N, O, P, Q, R, S), RET> for Engine where
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<L>, M, N, O, P, Q, R, S), RET> for Engine where
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<L, M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<L>, M, N, O, P, Q, R, S), RET> for Engine where
    L: Any + Clone,
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut L, M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (M, N, O, P, Q, R, S), RET> for Engine where
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<M>, N, O, P, Q, R, S), RET> for Engine where
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<M, N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<M>, N, O, P, Q, R, S), RET> for Engine where
    M: Any + Clone,
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut M, N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (N, O, P, Q, R, S), RET> for Engine where
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<N>, O, P, Q, R, S), RET> for Engine where
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<N, O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<N>, O, P, Q, R, S), RET> for Engine where
    N: Any + Clone,
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut N, O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<O, P, Q, R, S, FN, RET> RegisterFn<FN, (O, P, Q, R, S), RET> for Engine where
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<O, P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<O>, P, Q, R, S), RET> for Engine where
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<O, P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<O>, P, Q, R, S), RET> for Engine where
    O: Any + Clone,
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut O, P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<P, Q, R, S, FN, RET> RegisterFn<FN, (P, Q, R, S), RET> for Engine where
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<P, Q, R, S, FN, RET> RegisterFn<FN, (Ref<P>, Q, R, S), RET> for Engine where
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<P, Q, R, S, FN, RET> RegisterFn<FN, (Mut<P>, Q, R, S), RET> for Engine where
    P: Any + Clone,
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut P, Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<Q, R, S, FN, RET> RegisterFn<FN, (Q, R, S), RET> for Engine where
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<Q, R, S, FN, RET> RegisterFn<FN, (Ref<Q>, R, S), RET> for Engine where
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<Q, R, S, FN, RET> RegisterFn<FN, (Mut<Q>, R, S), RET> for Engine where
    Q: Any + Clone,
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut Q, R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<R, S, FN, RET> RegisterFn<FN, (R, S), RET> for Engine where
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<R, S, FN, RET> RegisterFn<FN, (Ref<R>, S), RET> for Engine where
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<R, S, FN, RET> RegisterFn<FN, (Mut<R>, S), RET> for Engine where
    R: Any + Clone,
    S: Any + Clone,
    FN: Fn(&mut R, S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<S, FN, RET> RegisterFn<FN, (S,), RET> for Engine where
    S: Any + Clone,
    FN: Fn(S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<S, FN, RET> RegisterFn<FN, (Ref<S>,), RET> for Engine where
    S: Any + Clone,
    FN: Fn(&S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<S, FN, RET> RegisterFn<FN, (Mut<S>,), RET> for Engine where
    S: Any + Clone,
    FN: Fn(&mut S) -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)

impl<FN, RET> RegisterFn<FN, (), RET> for Engine where
    FN: Fn() -> RET + 'static,
    RET: Any, 

fn register_fn(&mut self, name: &str, f: FN)