[go: up one dir, main page]

[−][src]Struct rhai::Engine

pub struct Engine<'e> { /* fields omitted */ }

Rhai main scripting engine.

use rhai::Engine;

let mut engine = Engine::new();

let result = engine.eval::<i64>("40 + 2")?;

println!("Answer: {}", result);  // prints 42

Currently, Engine is neither Send nor Sync. Turn on the sync feature to make it Send + Sync.

Methods

impl<'e> Engine<'e>[src]

Engine public API

pub fn register_type<T: Any + Clone>(&mut self)[src]

Register a custom type for use with the Engine. The type must implement Clone.

Example

#[derive(Debug, Clone, Eq, PartialEq)]
struct TestStruct {
    field: i64
}

impl TestStruct {
    fn new() -> Self                    { TestStruct { field: 1 } }
    fn update(&mut self, offset: i64)   { self.field += offset; }
}

use rhai::{Engine, RegisterFn};

let mut engine = Engine::new();

// Register the custom type.
engine.register_type::<TestStruct>();

engine.register_fn("new_ts", TestStruct::new);

// Use `register_fn` to register methods on the type.
engine.register_fn("update", TestStruct::update);

assert_eq!(
    engine.eval::<TestStruct>("let x = new_ts(); x.update(41); x")?,
    TestStruct { field: 42 }
);

pub fn register_type_with_name<T: Any + Clone>(&mut self, name: &str)[src]

Register a custom type for use with the Engine, with a pretty-print name for the type_of function. The type must implement Clone.

Example

#[derive(Clone)]
struct TestStruct {
    field: i64
}

impl TestStruct {
    fn new() -> Self { TestStruct { field: 1 } }
}

use rhai::{Engine, RegisterFn};

let mut engine = Engine::new();

// Register the custom type.
engine.register_type::<TestStruct>();

engine.register_fn("new_ts", TestStruct::new);

assert_eq!(
    engine.eval::<String>("let x = new_ts(); type_of(x)")?,
    "rust_out::TestStruct"
);

// Register the custom type with a name.
engine.register_type_with_name::<TestStruct>("Hello");

// Register methods on the type.
engine.register_fn("new_ts", TestStruct::new);

assert_eq!(
    engine.eval::<String>("let x = new_ts(); type_of(x)")?,
    "Hello"
);

pub fn register_iterator<T: Any, F: IteratorCallback>(&mut self, f: F)[src]

Register an iterator adapter for a type with the Engine. This is an advanced feature.

pub fn register_get<T, U, F>(&mut self, name: &str, callback: F) where
    T: Any + Clone,
    U: Any + Clone,
    F: ObjectGetCallback<T, U>, [src]

Register a getter function for a member of a registered type with the Engine.

The function signature must start with &mut self and not &self.

Example

#[derive(Clone)]
struct TestStruct {
    field: i64
}

impl TestStruct {
    fn new() -> Self                { TestStruct { field: 1 } }

    // Even a getter must start with `&mut self` and not `&self`.
    fn get_field(&mut self) -> i64  { self.field }
}

use rhai::{Engine, RegisterFn};

let mut engine = Engine::new();

// Register the custom type.
engine.register_type::<TestStruct>();

engine.register_fn("new_ts", TestStruct::new);

// Register a getter on a property (notice it doesn't have to be the same name).
engine.register_get("xyz", TestStruct::get_field);

assert_eq!(engine.eval::<i64>("let a = new_ts(); a.xyz")?, 1);

pub fn register_set<T, U, F>(&mut self, name: &str, callback: F) where
    T: Any + Clone,
    U: Any + Clone,
    F: ObjectSetCallback<T, U>, [src]

Register a setter function for a member of a registered type with the Engine.

Example

#[derive(Debug, Clone, Eq, PartialEq)]
struct TestStruct {
    field: i64
}

impl TestStruct {
    fn new() -> Self                        { TestStruct { field: 1 } }
    fn set_field(&mut self, new_val: i64)   { self.field = new_val; }
}

use rhai::{Engine, RegisterFn};

let mut engine = Engine::new();

// Register the custom type.
engine.register_type::<TestStruct>();

engine.register_fn("new_ts", TestStruct::new);

// Register a setter on a property (notice it doesn't have to be the same name)
engine.register_set("xyz", TestStruct::set_field);

// Notice that, with a getter, there is no way to get the property value
assert_eq!(
    engine.eval::<TestStruct>("let a = new_ts(); a.xyz = 42; a")?,
    TestStruct { field: 42 }
);

pub fn register_get_set<T, U, G, S>(&mut self, name: &str, get_fn: G, set_fn: S) where
    T: Any + Clone,
    U: Any + Clone,
    G: ObjectGetCallback<T, U>,
    S: ObjectSetCallback<T, U>, [src]

Shorthand for registering both getter and setter functions of a registered type with the Engine.

All function signatures must start with &mut self and not &self.

Example

#[derive(Clone)]
struct TestStruct {
    field: i64
}

impl TestStruct {
    fn new() -> Self                        { TestStruct { field: 1 } }
    fn get_field(&mut self) -> i64          { self.field }
    // Even a getter must start with `&mut self` and not `&self`.
    fn set_field(&mut self, new_val: i64)   { self.field = new_val; }
}

use rhai::{Engine, RegisterFn};

let mut engine = Engine::new();

// Register the custom type.
engine.register_type::<TestStruct>();

engine.register_fn("new_ts", TestStruct::new);

// Register a getter and a setter on a property
// (notice it doesn't have to be the same name)
engine.register_get_set("xyz", TestStruct::get_field, TestStruct::set_field);

assert_eq!(engine.eval::<i64>("let a = new_ts(); a.xyz = 42; a.xyz")?, 42);

pub fn compile(&self, input: &str) -> Result<AST, ParseError>[src]

Compile a string into an AST, which can be used later for evaluation.

Example

use rhai::Engine;

let mut engine = Engine::new();

// Compile a script to an AST and store it for later evaluation
let ast = engine.compile("40 + 2")?;

for _ in 0..42 {
    assert_eq!(engine.eval_ast::<i64>(&ast)?, 42);
}

pub fn compile_with_scope(
    &self,
    scope: &Scope,
    input: &str
) -> Result<AST, ParseError>[src]

Compile a string into an AST using own scope, which can be used later for evaluation. The scope is useful for passing constants into the script for optimization when using OptimizationLevel::Full.

Example

use rhai::{Engine, Scope, OptimizationLevel};

let mut engine = Engine::new();

// Set optimization level to 'Full' so the Engine can fold constants
// into function calls and operators.
engine.set_optimization_level(OptimizationLevel::Full);

// Create initialized scope
let mut scope = Scope::new();
scope.push_constant("x", 42_i64);   // 'x' is a constant

// Compile a script to an AST and store it for later evaluation.
// Notice that `Full` optimization is on, so constants are folded
// into function calls and operators.
let ast = engine.compile_with_scope(&mut scope,
            "if x > 40 { x } else { 0 }"    // all 'x' are replaced with 42
)?;

// Normally this would have failed because no scope is passed into the 'eval_ast'
// call and so the variable 'x' does not exist.  Here, it passes because the script
// has been optimized and all references to 'x' are already gone.
assert_eq!(engine.eval_ast::<i64>(&ast)?, 42);

pub fn compile_file(&self, path: PathBuf) -> Result<AST, EvalAltResult>[src]

Compile a script file into an AST, which can be used later for evaluation.

Example

use rhai::Engine;

let mut engine = Engine::new();

// Compile a script file to an AST and store it for later evaluation.
// Notice that a PathBuf is required which can easily be constructed from a string.
let ast = engine.compile_file("script.rhai".into())?;

for _ in 0..42 {
    engine.eval_ast::<i64>(&ast)?;
}

pub fn compile_file_with_scope(
    &self,
    scope: &Scope,
    path: PathBuf
) -> Result<AST, EvalAltResult>[src]

Compile a script file into an AST using own scope, which can be used later for evaluation. The scope is useful for passing constants into the script for optimization when using OptimizationLevel::Full.

Example

use rhai::{Engine, Scope, OptimizationLevel};

let mut engine = Engine::new();

// Set optimization level to 'Full' so the Engine can fold constants.
engine.set_optimization_level(OptimizationLevel::Full);

// Create initialized scope
let mut scope = Scope::new();
scope.push_constant("x", 42_i64);   // 'x' is a constant

// Compile a script to an AST and store it for later evaluation.
// Notice that a PathBuf is required which can easily be constructed from a string.
let ast = engine.compile_file_with_scope(&mut scope, "script.rhai".into())?;

let result = engine.eval_ast::<i64>(&ast)?;

pub fn compile_expression(&self, input: &str) -> Result<AST, ParseError>[src]

Compile a string containing an expression into an AST, which can be used later for evaluation.

Example

use rhai::Engine;

let mut engine = Engine::new();

// Compile a script to an AST and store it for later evaluation
let ast = engine.compile_expression("40 + 2")?;

for _ in 0..42 {
    assert_eq!(engine.eval_ast::<i64>(&ast)?, 42);
}

pub fn compile_expression_with_scope(
    &self,
    scope: &Scope,
    input: &str
) -> Result<AST, ParseError>[src]

Compile a string containing an expression into an AST using own scope, which can be used later for evaluation.

The scope is useful for passing constants into the script for optimization when using OptimizationLevel::Full.

Example

use rhai::{Engine, Scope, OptimizationLevel};

let mut engine = Engine::new();

// Set optimization level to 'Full' so the Engine can fold constants
// into function calls and operators.
engine.set_optimization_level(OptimizationLevel::Full);

// Create initialized scope
let mut scope = Scope::new();
scope.push_constant("x", 10_i64);   // 'x' is a constant

// Compile a script to an AST and store it for later evaluation.
// Notice that `Full` optimization is on, so constants are folded
// into function calls and operators.
let ast = engine.compile_expression_with_scope(&mut scope,
            "2 + (x + x) * 2"    // all 'x' are replaced with 10
)?;

// Normally this would have failed because no scope is passed into the 'eval_ast'
// call and so the variable 'x' does not exist.  Here, it passes because the script
// has been optimized and all references to 'x' are already gone.
assert_eq!(engine.eval_ast::<i64>(&ast)?, 42);

pub fn eval_file<T: Any + Clone>(
    &mut self,
    path: PathBuf
) -> Result<T, EvalAltResult>[src]

Evaluate a script file.

Example

use rhai::Engine;

let mut engine = Engine::new();

// Notice that a PathBuf is required which can easily be constructed from a string.
let result = engine.eval_file::<i64>("script.rhai".into())?;

pub fn eval_file_with_scope<T: Any + Clone>(
    &mut self,
    scope: &mut Scope,
    path: PathBuf
) -> Result<T, EvalAltResult>[src]

Evaluate a script file with own scope.

Example

use rhai::{Engine, Scope};

let mut engine = Engine::new();

// Create initialized scope
let mut scope = Scope::new();
scope.push("x", 42_i64);

// Notice that a PathBuf is required which can easily be constructed from a string.
let result = engine.eval_file_with_scope::<i64>(&mut scope, "script.rhai".into())?;

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

Evaluate a string.

Example

use rhai::Engine;

let mut engine = Engine::new();

assert_eq!(engine.eval::<i64>("40 + 2")?, 42);

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

Evaluate a string with own scope.

Example

use rhai::{Engine, Scope};

let mut engine = Engine::new();

// Create initialized scope
let mut scope = Scope::new();
scope.push("x", 40_i64);

assert_eq!(engine.eval_with_scope::<i64>(&mut scope, "x = x + 2; x")?, 42);
assert_eq!(engine.eval_with_scope::<i64>(&mut scope, "x = x + 2; x")?, 44);

// The variable in the scope is modified
assert_eq!(scope.get_value::<i64>("x").expect("variable x should exist"), 44);

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

Evaluate a string containing an expression.

Example

use rhai::Engine;

let mut engine = Engine::new();

assert_eq!(engine.eval_expression::<i64>("40 + 2")?, 42);

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

Evaluate a string containing an expression with own scope.

Example

use rhai::{Engine, Scope};

let mut engine = Engine::new();

// Create initialized scope
let mut scope = Scope::new();
scope.push("x", 40_i64);

assert_eq!(engine.eval_expression_with_scope::<i64>(&mut scope, "x + 2")?, 42);

pub fn eval_ast<T: Any + Clone>(
    &mut self,
    ast: &AST
) -> Result<T, EvalAltResult>[src]

Evaluate an AST.

Example

use rhai::Engine;

let mut engine = Engine::new();

// Compile a script to an AST and store it for later evaluation
let ast = engine.compile("40 + 2")?;

// Evaluate it
assert_eq!(engine.eval_ast::<i64>(&ast)?, 42);

pub fn eval_ast_with_scope<T: Any + Clone>(
    &mut self,
    scope: &mut Scope,
    ast: &AST
) -> Result<T, EvalAltResult>[src]

Evaluate an AST with own scope.

Example

use rhai::{Engine, Scope};

let mut engine = Engine::new();

// Compile a script to an AST and store it for later evaluation
let ast = engine.compile("x + 2")?;

// Create initialized scope
let mut scope = Scope::new();
scope.push("x", 40_i64);

// Compile a script to an AST and store it for later evaluation
let ast = engine.compile("x = x + 2; x")?;

// Evaluate it
assert_eq!(engine.eval_ast_with_scope::<i64>(&mut scope, &ast)?, 42);
assert_eq!(engine.eval_ast_with_scope::<i64>(&mut scope, &ast)?, 44);

// The variable in the scope is modified
assert_eq!(scope.get_value::<i64>("x").expect("variable x should exist"), 44);

pub fn consume_file(&mut self, path: PathBuf) -> Result<(), EvalAltResult>[src]

Evaluate a file, but throw away the result and only return error (if any). Useful for when you don't need the result, but still need to keep track of possible errors.

pub fn consume_file_with_scope(
    &mut self,
    scope: &mut Scope,
    path: PathBuf
) -> Result<(), EvalAltResult>[src]

Evaluate a file with own scope, but throw away the result and only return error (if 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>[src]

Evaluate a string, but throw away the result and only return error (if 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>[src]

Evaluate a string with own scope, but throw away the result and only return error (if any). Useful for when you don't need the result, but still need to keep track of possible errors.

pub fn consume_ast(&mut self, ast: &AST) -> Result<(), EvalAltResult>[src]

Evaluate an AST, but throw away the result and only return error (if any). Useful for when you don't need the result, but still need to keep track of possible errors.

pub fn consume_ast_with_scope(
    &mut self,
    scope: &mut Scope,
    ast: &AST
) -> Result<(), EvalAltResult>[src]

Evaluate an AST with own scope, but throw away the result and only return error (if any). Useful for when you don't need the result, but still need to keep track of possible errors.

pub fn call_fn0<T: Any + Clone>(
    &mut self,
    scope: &mut Scope,
    ast: &AST,
    name: &str
) -> Result<T, EvalAltResult>[src]

Call a script function defined in an AST with no argument.

Example

use rhai::{Engine, Scope};

let mut engine = Engine::new();

let ast = engine.compile("fn num() { 42 + foo }")?;

let mut scope = Scope::new();
scope.push("foo", 42_i64);

// Call the script-defined function
let result: i64 = engine.call_fn0(&mut scope, &ast, "num")?;

assert_eq!(result, 84);

pub fn call_fn1<A: Any + Clone, T: Any + Clone>(
    &mut self,
    scope: &mut Scope,
    ast: &AST,
    name: &str,
    arg: A
) -> Result<T, EvalAltResult>[src]

Call a script function defined in an AST with one argument.

Example

use rhai::{Engine, Scope};

let mut engine = Engine::new();

let ast = engine.compile("fn inc(x) { x + foo }")?;

let mut scope = Scope::new();
scope.push("foo", 42_i64);

// Call the script-defined function
let result: i64 = engine.call_fn1(&mut scope, &ast, "inc", 123_i64)?;

assert_eq!(result, 165);

pub fn call_fn<A: FuncArgs, T: Any + Clone>(
    &mut self,
    scope: &mut Scope,
    ast: &AST,
    name: &str,
    args: A
) -> Result<T, EvalAltResult>[src]

Call a script function defined in an AST with multiple arguments.

Example

use rhai::{Engine, Scope};

let mut engine = Engine::new();

let ast = engine.compile("fn add(x, y) { len(x) + y + foo }")?;

let mut scope = Scope::new();
scope.push("foo", 42_i64);

// Call the script-defined function
let result: i64 = engine.call_fn(&mut scope, &ast, "add", (String::from("abc"), 123_i64))?;

assert_eq!(result, 168);

pub fn optimize_ast(&self, scope: &Scope, ast: AST) -> AST[src]

Optimize the AST with constants defined in an external Scope. An optimized copy of the AST is returned while the original AST is consumed.

Although optimization is performed by default during compilation, sometimes it is necessary to re-optimize an AST. For example, when working with constants that are passed in via an external scope, it will be more efficient to optimize the AST once again to take advantage of the new constants.

With this method, it is no longer necessary to recompile a large script. The script AST can be compiled just once. Before evaluation, constants are passed into the Engine via an external scope (i.e. with scope.push_constant(...)). Then, the `AST is cloned and the copy re-optimized before running.

pub fn on_print(&mut self, callback: impl FnMut(&str) + 'e)[src]

Override default action of print (print to stdout using println!)

Example

use rhai::Engine;

let mut result = String::from("");
{
let mut engine = Engine::new();

// Override action of 'print' function
engine.on_print(|s| result.push_str(s));
engine.consume("print(40 + 2);")?;
}
assert_eq!(result, "42");

pub fn on_debug(&mut self, callback: impl FnMut(&str) + 'e)[src]

Override default action of debug (print to stdout using println!)

Example

use rhai::Engine;

let mut result = String::from("");
{
let mut engine = Engine::new();

// Override action of 'debug' function
engine.on_debug(|s| result.push_str(s));
engine.consume(r#"debug("hello");"#)?;
}
assert_eq!(result, "\"hello\"");

impl<'_> Engine<'_>[src]

pub fn new() -> Self[src]

Create a new Engine

pub fn new_raw() -> Self[src]

Create a new Engine with minimal configurations - i.e. without pretty-print type names etc.

pub fn set_optimization_level(&mut self, optimization_level: OptimizationLevel)[src]

Control whether and how the Engine will optimize an AST after compilation

Not available under the no_optimize feature.

pub fn set_max_call_levels(&mut self, levels: usize)[src]

Set the maximum levels of function calls allowed for a script in order to avoid infinite recursion and stack overflows.

pub fn clear_functions(&mut self)[src]

Clean up all script-defined functions within the Engine.

Trait Implementations

impl<'_> Default for Engine<'_>[src]

impl<'_, FN: Fn() -> Dynamic + 'static> RegisterDynamicFn<FN, ()> for Engine<'_>[src]

impl<'_, A: Any + Clone, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, A: Any + Clone, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<A>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<B>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<C>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<D>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<E>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<F>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<G>, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<H>, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut J, K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<J>, K, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut K, L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<K>, L, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut L, M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<L>, M, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut M, N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<M>, N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<N>, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<P>, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<Q>, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<R>, S, T, U, V)> for Engine<'_>[src]

impl<'_, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<S>, T, U, V)> for Engine<'_>[src]

impl<'_, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<T>, U, V)> for Engine<'_>[src]

impl<'_, U: Any + Clone, V: Any + Clone, FN: Fn(&mut U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<U>, V)> for Engine<'_>[src]

impl<'_, V: Any + Clone, FN: Fn(&mut V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Mut<V>,)> for Engine<'_>[src]

impl<'_, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(N, P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (N, P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(P, Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (P, Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(Q, R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (Q, R, S, T, U, V)> for Engine<'_>[src]

impl<'_, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(R, S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (R, S, T, U, V)> for Engine<'_>[src]

impl<'_, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(S, T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (S, T, U, V)> for Engine<'_>[src]

impl<'_, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(T, U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (T, U, V)> for Engine<'_>[src]

impl<'_, U: Any + Clone, V: Any + Clone, FN: Fn(U, V) -> Dynamic + 'static> RegisterDynamicFn<FN, (U, V)> for Engine<'_>[src]

impl<'_, V: Any + Clone, FN: Fn(V) -> Dynamic + 'static> RegisterDynamicFn<FN, (V,)> for Engine<'_>[src]

impl<'_, FN: Fn() -> RET + 'static, RET: Any> RegisterFn<FN, (), RET> for Engine<'_>[src]

impl<'_, A: Any + Clone, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, A: Any + Clone, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<A>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<B>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<C>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<D>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<E>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<F>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<G>, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<H>, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<J>, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut K, L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<K>, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut L, M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<L>, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut M, N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<M>, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<N>, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<P>, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<Q>, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<R>, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<S>, T, U, V), RET> for Engine<'_>[src]

impl<'_, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<T>, U, V), RET> for Engine<'_>[src]

impl<'_, U: Any + Clone, V: Any + Clone, FN: Fn(&mut U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<U>, V), RET> for Engine<'_>[src]

impl<'_, V: Any + Clone, FN: Fn(&mut V) -> RET + 'static, RET: Any> RegisterFn<FN, (Mut<V>,), RET> for Engine<'_>[src]

impl<'_, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(N, P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(P, Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(Q, R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(R, S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(S, T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (S, T, U, V), RET> for Engine<'_>[src]

impl<'_, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(T, U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (T, U, V), RET> for Engine<'_>[src]

impl<'_, U: Any + Clone, V: Any + Clone, FN: Fn(U, V) -> RET + 'static, RET: Any> RegisterFn<FN, (U, V), RET> for Engine<'_>[src]

impl<'_, V: Any + Clone, FN: Fn(V) -> RET + 'static, RET: Any> RegisterFn<FN, (V,), RET> for Engine<'_>[src]

impl<'_, FN: Fn() -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (), RET> for Engine<'_>[src]

impl<'_, A: Any + Clone, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, A: Any + Clone, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<A>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, B: Any + Clone, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<B>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, C: Any + Clone, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<C>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, D: Any + Clone, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<D>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, E: Any + Clone, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<E>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, F: Any + Clone, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<F>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, G: Any + Clone, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<G>, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, H: Any + Clone, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<H>, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, J: Any + Clone, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<J>, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, K: Any + Clone, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<K>, L, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, L: Any + Clone, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut L, M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<L>, M, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, M: Any + Clone, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut M, N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<M>, N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<N>, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<P>, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<Q>, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<R>, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<S>, T, U, V), RET> for Engine<'_>[src]

impl<'_, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(&mut T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<T>, U, V), RET> for Engine<'_>[src]

impl<'_, U: Any + Clone, V: Any + Clone, FN: Fn(&mut U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<U>, V), RET> for Engine<'_>[src]

impl<'_, V: Any + Clone, FN: Fn(&mut V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Mut<V>,), RET> for Engine<'_>[src]

impl<'_, N: Any + Clone, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(N, P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (N, P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, P: Any + Clone, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(P, Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (P, Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, Q: Any + Clone, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(Q, R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (Q, R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, R: Any + Clone, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(R, S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (R, S, T, U, V), RET> for Engine<'_>[src]

impl<'_, S: Any + Clone, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(S, T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (S, T, U, V), RET> for Engine<'_>[src]

impl<'_, T: Any + Clone, U: Any + Clone, V: Any + Clone, FN: Fn(T, U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (T, U, V), RET> for Engine<'_>[src]

impl<'_, U: Any + Clone, V: Any + Clone, FN: Fn(U, V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (U, V), RET> for Engine<'_>[src]

impl<'_, V: Any + Clone, FN: Fn(V) -> Result<RET, EvalAltResult> + 'static, RET: Any> RegisterResultFn<FN, (V,), RET> for Engine<'_>[src]

Auto Trait Implementations

impl<'e> !RefUnwindSafe for Engine<'e>

impl<'e> !Send for Engine<'e>

impl<'e> !Sync for Engine<'e>

impl<'e> Unpin for Engine<'e>

impl<'e> !UnwindSafe for Engine<'e>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.