Struct rhai::plugin::Engine

pub struct Engine { /* fields omitted */ }

Rhai main scripting engine.

Thread Safety

Engine is re-entrant.

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

Example

use rhai::Engine;

let engine = Engine::new();

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

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

Implementations

impl Engine

pub fn new() -> Self

Create a new Engine

pub fn new_raw() -> Self

Create a new Engine with minimal built-in functions.

Use register_global_module to add packages of functions.

pub fn map_type_name<'a>(&'a self, name: &'a str) -> &'a str

Pretty-print a type name.

If a type is registered via register_type_with_name, the type name provided for the registration will be used.

impl Engine

Engine public API

pub fn register_fn<N, A, F>(&mut self, name: N, func: F) -> &mut Self where
    N: AsRef<str> + Into<Identifier>,
    F: RegisterNativeFunction<A, ()>, 

Register a custom function with the Engine.

Example

use rhai::Engine;

// Normal function
fn add(x: i64, y: i64) -> i64 {
    x + y
}

let mut engine = Engine::new();

engine.register_fn("add", add);

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

// You can also register a closure.
engine.register_fn("sub", |x: i64, y: i64| x - y );

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

pub fn register_result_fn<N, A, F, R>(&mut self, name: N, func: F) -> &mut Self where
    N: AsRef<str> + Into<Identifier>,
    F: RegisterNativeFunction<A, Result<R, Box<EvalAltResult>>>, 

Register a custom fallible function with the Engine.

Example

use rhai::{Engine, EvalAltResult};

// Normal function
fn div(x: i64, y: i64) -> Result<i64, Box<EvalAltResult>> {
    if y == 0 {
        // '.into()' automatically converts to 'Box<EvalAltResult::ErrorRuntime>'
        Err("division by zero!".into())
    } else {
        Ok(x / y)
    }
}

let mut engine = Engine::new();

engine.register_result_fn("div", div);

engine.eval::<i64>("div(42, 0)")
      .expect_err("expecting division by zero error!");

pub fn register_raw_fn<N, T>(
    &mut self,
    name: N,
    arg_types: &[TypeId],
    func: impl Fn(NativeCallContext<'_>, &mut FnCallArgs<'_>) -> Result<T, Box<EvalAltResult>> + SendSync + 'static
) -> &mut Self where
    N: AsRef<str> + Into<Identifier>,
    T: Variant + Clone, 

👎 Deprecated:

this function is volatile and may change

Register a function of the Engine.

WARNING - Low Level API

This function is very low level. It takes a list of TypeId’s indicating the actual types of the parameters.

Arguments are simply passed in as a mutable array of &mut Dynamic, The arguments are guaranteed to be of the correct types matching the TypeId’s.

To access a primary argument value (i.e. cloning is cheap), use: args[n].as_xxx().unwrap()

To access an argument value and avoid cloning, use std::mem::take(args[n]).cast::<T>(). Notice that this will consume the argument, replacing it with ().

To access the first mutable parameter, use args.get_mut(0).unwrap()

pub fn register_type<T: Variant + Clone>(&mut self) -> &mut Self

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                    { Self { field: 1 } }

    fn update(&mut self, offset: i64)   { self.field += offset; }
}

use rhai::Engine;

let mut engine = Engine::new();

// Register API for the custom type.
engine
    .register_type::<TestStruct>()
    .register_fn("new_ts", TestStruct::new)
    // Use `register_fn` to register methods on the type.
    .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: Variant + Clone>(
    &mut self,
    name: &str
) -> &mut Self

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 { Self { field: 1 } }
}

use rhai::Engine;

let mut engine = Engine::new();

// Register API for the custom type.
engine
    .register_type::<TestStruct>()
    .register_fn("new_ts", TestStruct::new);

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

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

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

pub fn register_iterator<T>(&mut self) -> &mut Self where
    T: Variant + Clone + IntoIterator,
    <T as IntoIterator>::Item: Variant + Clone, 

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

pub fn register_get<T: Variant + Clone, U: Variant + Clone>(
    &mut self,
    name: &str,
    get_fn: impl Fn(&mut T) -> U + SendSync + 'static
) -> &mut Self

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                { Self { field: 1 } }

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

use rhai::Engine;

let mut engine = Engine::new();

// Register API for the custom type.
engine
    .register_type::<TestStruct>()
    .register_fn("new_ts", TestStruct::new)
    // Register a getter on a property (notice it doesn't have to be the same name).
    .register_get("xyz", TestStruct::get_field);

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

pub fn register_get_result<T: Variant + Clone, U: Variant + Clone>(
    &mut self,
    name: &str,
    get_fn: impl Fn(&mut T) -> Result<U, Box<EvalAltResult>> + SendSync + 'static
) -> &mut Self

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

use rhai::{Engine, Dynamic, EvalAltResult};

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

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

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

let mut engine = Engine::new();

// Register API for the custom type.
engine
    .register_type::<TestStruct>()
    .register_fn("new_ts", TestStruct::new)
    // Register a getter on a property (notice it doesn't have to be the same name).
    .register_get_result("xyz", TestStruct::get_field);

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

pub fn register_set<T: Variant + Clone, U: Variant + Clone>(
    &mut self,
    name: &str,
    set_fn: impl Fn(&mut T, U) + SendSync + 'static
) -> &mut Self

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                        { Self { field: 1 } }

    fn set_field(&mut self, new_val: i64)   { self.field = new_val; }
}

use rhai::Engine;

let mut engine = Engine::new();

// Register API for the custom type.
engine
    .register_type::<TestStruct>()
    .register_fn("new_ts", TestStruct::new)
    // Register a setter on a property (notice it doesn't have to be the same name)
    .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_set_result<T: Variant + Clone, U: Variant + Clone>(
    &mut self,
    name: &str,
    set_fn: impl Fn(&mut T, U) -> Result<(), Box<EvalAltResult>> + SendSync + 'static
) -> &mut Self

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

Example

use rhai::{Engine, Dynamic, EvalAltResult};

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

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

    fn set_field(&mut self, new_val: i64) -> Result<(), Box<EvalAltResult>> {
        self.field = new_val;
        Ok(())
    }
}

let mut engine = Engine::new();

// Register API for the custom type.
engine
    .register_type::<TestStruct>()
    .register_fn("new_ts", TestStruct::new)
    // Register a setter on a property (notice it doesn't have to be the same name)
    .register_set_result("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: Variant + Clone, U: Variant + Clone>(
    &mut self,
    name: &str,
    get_fn: impl Fn(&mut T) -> U + SendSync + 'static,
    set_fn: impl Fn(&mut T, U) + SendSync + 'static
) -> &mut Self

Short-hand 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                        { Self { field: 1 } }

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

    fn set_field(&mut self, new_val: i64)   { self.field = new_val; }
}

use rhai::Engine;

let mut engine = Engine::new();

// Register API for the custom type.
engine
    .register_type::<TestStruct>()
    .register_fn("new_ts", TestStruct::new)
    // Register both a getter and a setter on a property
    // (notice it doesn't have to be the same name)
    .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 register_indexer_get<T: Variant + Clone, X: Variant + Clone, U: Variant + Clone>(
    &mut self,
    get_fn: impl Fn(&mut T, X) -> U + SendSync + 'static
) -> &mut Self

Register an index getter for a custom type with the Engine.

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

Panics

Panics if the type is Array, Map, String, ImmutableString or &str. Indexers for arrays, object maps and strings cannot be registered.

Example

#[derive(Clone)]
struct TestStruct {
    fields: Vec<i64>
}

impl TestStruct {
    fn new() -> Self { Self { fields: vec![1, 2, 3, 4, 5] } }

    // Even a getter must start with `&mut self` and not `&self`.
    fn get_field(&mut self, index: i64) -> i64 { self.fields[index as usize] }
}

use rhai::Engine;

let mut engine = Engine::new();

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

engine
    .register_fn("new_ts", TestStruct::new)
    // Register an indexer.
    .register_indexer_get(TestStruct::get_field);

assert_eq!(engine.eval::<i64>("let a = new_ts(); a[2]")?, 3);

pub fn register_indexer_get_result<T: Variant + Clone, X: Variant + Clone, U: Variant + Clone>(
    &mut self,
    get_fn: impl Fn(&mut T, X) -> Result<U, Box<EvalAltResult>> + SendSync + 'static
) -> &mut Self

Register an index getter for a custom type with the Engine.

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

Panics

Panics if the type is Array, Map, String, ImmutableString or &str. Indexers for arrays, object maps and strings cannot be registered.

Example

use rhai::{Engine, Dynamic, EvalAltResult};

#[derive(Clone)]
struct TestStruct {
    fields: Vec<i64>
}

impl TestStruct {
    fn new() -> Self { Self { fields: vec![1, 2, 3, 4, 5] } }

    // Even a getter must start with `&mut self` and not `&self`.
    fn get_field(&mut self, index: i64) -> Result<i64, Box<EvalAltResult>> {
        Ok(self.fields[index as usize])
    }
}

let mut engine = Engine::new();

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

engine
    .register_fn("new_ts", TestStruct::new)
    // Register an indexer.
    .register_indexer_get_result(TestStruct::get_field);

assert_eq!(engine.eval::<i64>("let a = new_ts(); a[2]")?, 3);

pub fn register_indexer_set<T: Variant + Clone, X: Variant + Clone, U: Variant + Clone>(
    &mut self,
    set_fn: impl Fn(&mut T, X, U) + SendSync + 'static
) -> &mut Self

Register an index setter for a custom type with the Engine.

Panics

Panics if the type is Array, Map, String, ImmutableString or &str. Indexers for arrays, object maps and strings cannot be registered.

Example

#[derive(Clone)]
struct TestStruct {
    fields: Vec<i64>
}

impl TestStruct {
    fn new() -> Self { Self { fields: vec![1, 2, 3, 4, 5] } }

    fn set_field(&mut self, index: i64, value: i64) { self.fields[index as usize] = value; }
}

use rhai::Engine;

let mut engine = Engine::new();

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

engine
    .register_fn("new_ts", TestStruct::new)
    // Register an indexer.
    .register_indexer_set(TestStruct::set_field);

assert_eq!(
    engine.eval::<TestStruct>("let a = new_ts(); a[2] = 42; a")?.fields[2],
    42
);

pub fn register_indexer_set_result<T: Variant + Clone, X: Variant + Clone, U: Variant + Clone>(
    &mut self,
    set_fn: impl Fn(&mut T, X, U) -> Result<(), Box<EvalAltResult>> + SendSync + 'static
) -> &mut Self

Register an index setter for a custom type with the Engine.

Panics

Panics if the type is Array, Map, String, ImmutableString or &str. Indexers for arrays, object maps and strings cannot be registered.

Example

use rhai::{Engine, Dynamic, EvalAltResult};

#[derive(Clone)]
struct TestStruct {
    fields: Vec<i64>
}

impl TestStruct {
    fn new() -> Self { Self { fields: vec![1, 2, 3, 4, 5] } }

    fn set_field(&mut self, index: i64, value: i64) -> Result<(), Box<EvalAltResult>> {
        self.fields[index as usize] = value;
        Ok(())
    }
}

let mut engine = Engine::new();

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

engine
    .register_fn("new_ts", TestStruct::new)
    // Register an indexer.
    .register_indexer_set_result(TestStruct::set_field);

assert_eq!(
    engine.eval::<TestStruct>("let a = new_ts(); a[2] = 42; a")?.fields[2],
    42
);

pub fn register_indexer_get_set<T: Variant + Clone, X: Variant + Clone, U: Variant + Clone>(
    &mut self,
    get_fn: impl Fn(&mut T, X) -> U + SendSync + 'static,
    set_fn: impl Fn(&mut T, X, U) + SendSync + 'static
) -> &mut Self

Short-hand for register both index getter and setter functions for a custom type with the Engine.

Panics

Panics if the type is Array, Map, String, ImmutableString or &str. Indexers for arrays, object maps and strings cannot be registered.

Example

#[derive(Clone)]
struct TestStruct {
    fields: Vec<i64>
}

impl TestStruct {
    fn new() -> Self                                { Self { fields: vec![1, 2, 3, 4, 5] } }

    // Even a getter must start with `&mut self` and not `&self`.
    fn get_field(&mut self, index: i64) -> i64      { self.fields[index as usize] }

    fn set_field(&mut self, index: i64, value: i64) { self.fields[index as usize] = value; }
}

use rhai::Engine;

let mut engine = Engine::new();

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

engine
    .register_fn("new_ts", TestStruct::new)
    // Register an indexer.
    .register_indexer_get_set(TestStruct::get_field, TestStruct::set_field);

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

pub fn register_global_module(&mut self, module: Shared<Module>) -> &mut Self

Register a shared Module into the global namespace of Engine.

All functions and type iterators are automatically available to scripts without namespace qualifications.

Sub-modules and variables are ignored.

When searching for functions, modules loaded later are preferred. In other words, loaded modules are searched in reverse order.

pub fn load_package(&mut self, module: impl Into<Shared<Module>>) -> &mut Self

👎 Deprecated since 0.19.9:

use register_global_module instead

Register a shared Module into the global namespace of Engine. This function is deprecated and will be removed in the future. Use register_global_module instead.

pub fn register_static_module(
    &mut self,
    name: impl AsRef<str> + Into<Identifier>,
    module: Shared<Module>
) -> &mut Self

Register a shared Module as a static module namespace with the Engine.

Functions marked FnNamespace::Global and type iterators are exposed to scripts without namespace qualifications.

Example

use rhai::{Engine, Shared, Module};

let mut engine = Engine::new();

// Create the module
let mut module = Module::new();
module.set_native_fn("calc", |x: i64| Ok(x + 1));

let module: Shared<Module> = module.into();

engine
    // Register the module as a fixed sub-module
    .register_static_module("foo::bar::baz", module.clone())
    // Multiple registrations to the same partial path is also OK!
    .register_static_module("foo::bar::hello", module.clone())
    .register_static_module("CalcService", module);

assert_eq!(engine.eval::<i64>("foo::bar::baz::calc(41)")?, 42);
assert_eq!(engine.eval::<i64>("foo::bar::hello::calc(41)")?, 42);
assert_eq!(engine.eval::<i64>("CalcService::calc(41)")?, 42);

pub fn register_module(
    &mut self,
    name: impl AsRef<str> + Into<Identifier>,
    module: impl Into<Shared<Module>>
) -> &mut Self

👎 Deprecated since 0.19.9:

use register_static_module instead

Register a shared Module as a static module namespace with the Engine. This function is deprecated and will be removed in the future. Use register_static_module instead.

pub fn compile(&self, script: &str) -> Result<AST, ParseError>

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

Example

use rhai::Engine;

let 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<'_>,
    script: &str
) -> Result<AST, ParseError>

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_into_self_contained(
    &self,
    scope: &Scope<'_>,
    script: &str
) -> Result<AST, Box<EvalAltResult>>

Compile a string into an AST using own scope, which can be used later for evaluation, embedding all imported modules.

Modules referred by import statements containing literal string paths are eagerly resolved via the current module resolver and embedded into the resultant AST. When it is evaluated later, import statement directly recall pre-resolved modules and the resolution process is not performed again.

pub fn compile_scripts_with_scope(
    &self,
    scope: &Scope<'_>,
    scripts: &[&str]
) -> Result<AST, ParseError>

When passed a list of strings, first join the strings into one large script, and then compile them 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.

Note

All strings are simply parsed one after another with nothing inserted in between, not even a newline or space.

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 made up of script segments 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_scripts_with_scope(&mut scope, &[
            "if x > 40",            // all 'x' are replaced with 42
            "{ x } el",
            "se { 0 }"              // segments do not need to be valid scripts!
])?;

// 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, Box<EvalAltResult>>

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

Not available under no_std or WASM.

Example

use rhai::Engine;

let 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, Box<EvalAltResult>>

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

Not available under no_std or WASM.

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 parse_json(
    &self,
    json: impl AsRef<str>,
    has_null: bool
) -> Result<Map, Box<EvalAltResult>>

Parse a JSON string into an object map. This is a light-weight alternative to using, say, serde_json to deserialize the JSON.

The JSON string must be an object hash. It cannot be a simple scalar value.

Set has_null to true in order to map null values to (). Setting it to false will cause an ErrorVariableNotFound error during parsing.

JSON With Sub-Objects

This method assumes no sub-objects in the JSON string. That is because the syntax of a JSON sub-object (or object hash), { .. }, is different from Rhai’s syntax, #{ .. }. Parsing a JSON string with sub-objects will cause a syntax error.

If it is certain that the character { never appears in any text string within the JSON object, which is a valid assumption for many use cases, then globally replace { with #{ before calling this method.

Example

use rhai::{Engine, Map};

let engine = Engine::new();

let map = engine.parse_json(
    r#"{"a":123, "b":42, "c":{"x":false, "y":true}, "d":null}"#
        .replace("{", "#{").as_str(), true)?;

assert_eq!(map.len(), 4);
assert_eq!(map["a"].as_int().unwrap(), 123);
assert_eq!(map["b"].as_int().unwrap(), 42);
assert!(map["d"].is::<()>());

let c = map["c"].read_lock::<Map>().unwrap();
assert_eq!(c["x"].as_bool().unwrap(), false);

pub fn compile_expression(&self, script: &str) -> Result<AST, ParseError>

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

Example

use rhai::Engine;

let 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<'_>,
    script: &str
) -> Result<AST, ParseError>

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: Variant + Clone>(
    &self,
    path: PathBuf
) -> Result<T, Box<EvalAltResult>>

Evaluate a script file.

Not available under no_std or WASM.

Example

use rhai::Engine;

let 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: Variant + Clone>(
    &self,
    scope: &mut Scope<'_>,
    path: PathBuf
) -> Result<T, Box<EvalAltResult>>

Evaluate a script file with own scope.

Not available under no_std or WASM.

Example

use rhai::{Engine, Scope};

let 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: Variant + Clone>(
    &self,
    script: &str
) -> Result<T, Box<EvalAltResult>>

Evaluate a string.

Example

use rhai::Engine;

let engine = Engine::new();

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

pub fn eval_with_scope<T: Variant + Clone>(
    &self,
    scope: &mut Scope<'_>,
    script: &str
) -> Result<T, Box<EvalAltResult>>

Evaluate a string with own scope.

Example

use rhai::{Engine, Scope};

let 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 += 2; x")?, 42);
assert_eq!(engine.eval_with_scope::<i64>(&mut scope, "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: Variant + Clone>(
    &self,
    script: &str
) -> Result<T, Box<EvalAltResult>>

Evaluate a string containing an expression.

Example

use rhai::Engine;

let engine = Engine::new();

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

pub fn eval_expression_with_scope<T: Variant + Clone>(
    &self,
    scope: &mut Scope<'_>,
    script: &str
) -> Result<T, Box<EvalAltResult>>

Evaluate a string containing an expression with own scope.

Example

use rhai::{Engine, Scope};

let 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: Variant + Clone>(
    &self,
    ast: &AST
) -> Result<T, Box<EvalAltResult>>

Evaluate an AST.

Example

use rhai::Engine;

let 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: Variant + Clone>(
    &self,
    scope: &mut Scope<'_>,
    ast: &AST
) -> Result<T, Box<EvalAltResult>>

Evaluate an AST with own scope.

Example

use rhai::{Engine, Scope};

let 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 += 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(&self, path: PathBuf) -> Result<(), Box<EvalAltResult>>

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.

Not available under no_std or WASM.

pub fn consume_file_with_scope(
    &self,
    scope: &mut Scope<'_>,
    path: PathBuf
) -> Result<(), Box<EvalAltResult>>

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.

Not available under no_std or WASM.

pub fn consume(&self, script: &str) -> Result<(), Box<EvalAltResult>>

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(
    &self,
    scope: &mut Scope<'_>,
    script: &str
) -> Result<(), Box<EvalAltResult>>

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(&self, ast: &AST) -> Result<(), Box<EvalAltResult>>

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(
    &self,
    scope: &mut Scope<'_>,
    ast: &AST
) -> Result<(), Box<EvalAltResult>>

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_fn<T: Variant + Clone>(
    &self,
    scope: &mut Scope<'_>,
    ast: &AST,
    name: impl AsRef<str>,
    args: impl FuncArgs
) -> Result<T, Box<EvalAltResult>>

Call a script function defined in an AST with multiple arguments. Arguments are passed as a tuple.

Warning

The AST is not evaluated before calling the function. The function is called as-is.

If the AST needs to be evaluated before calling the function (usually to load external modules), use call_fn_dynamic.

Example

use rhai::{Engine, Scope};

let engine = Engine::new();

let ast = engine.compile(r"
    fn add(x, y) { len(x) + y + foo }
    fn add1(x)   { len(x) + 1 + foo }
    fn bar()     { foo/2 }
")?;

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", ( "abc", 123_i64 ) )?;
assert_eq!(result, 168);

let result: i64 = engine.call_fn(&mut scope, &ast, "add1", ( "abc", ) )?;
//                                                         ^^^^^^^^^^ tuple of one
assert_eq!(result, 46);

let result: i64 = engine.call_fn(&mut scope, &ast, "bar", () )?;
assert_eq!(result, 21);

pub fn call_fn_dynamic(
    &self,
    scope: &mut Scope<'_>,
    ast: &AST,
    eval_ast: bool,
    name: impl AsRef<str>,
    this_ptr: Option<&mut Dynamic>,
    arg_values: impl AsMut<[Dynamic]>
) -> Result<Dynamic, Box<EvalAltResult>>

Call a script function defined in an AST with multiple Dynamic arguments and optionally a value for binding to the this pointer.

There is also an option to evaluate the AST (e.g. to configuration the environment) before calling the function.

WARNING

All the arguments are consumed, meaning that they’re replaced by (). This is to avoid unnecessarily cloning the arguments. Do not use the arguments after this call. If they are needed afterwards, clone them before calling this function.

Example

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

let engine = Engine::new();

let ast = engine.compile(r"
    fn add(x, y) { len(x) + y + foo }
    fn add1(x)   { len(x) + 1 + foo }
    fn bar()     { foo/2 }
    fn action(x) { this += x; }         // function using 'this' pointer
")?;

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

// Call the script-defined function
let result = engine.call_fn_dynamic(&mut scope, &ast, false, "add", None, [ "abc".into(), 123_i64.into() ])?;
//                                                                  ^^^^ no 'this' pointer
assert_eq!(result.cast::<i64>(), 168);

let result = engine.call_fn_dynamic(&mut scope, &ast, false, "add1", None, [ "abc".into() ])?;
assert_eq!(result.cast::<i64>(), 46);

let result = engine.call_fn_dynamic(&mut scope, &ast, false, "bar", None, [])?;
assert_eq!(result.cast::<i64>(), 21);

let mut value: Dynamic = 1_i64.into();
let result = engine.call_fn_dynamic(&mut scope, &ast, false, "action", Some(&mut value), [ 41_i64.into() ])?;
//                                                                     ^^^^^^^^^^^^^^^^ binding the 'this' pointer
assert_eq!(value.as_int().unwrap(), 42);

pub fn optimize_ast(
    &self,
    scope: &Scope<'_>,
    ast: AST,
    optimization_level: OptimizationLevel
) -> AST

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 gen_fn_signatures(&self, include_packages: bool) -> Vec<String>

Generate a list of all registered functions. Available under the metadata feature only.

Functions from the following sources are included, in order:

1. Functions registered into the global namespace
2. Functions in registered sub-modules
3. Functions in packages (optional)

pub fn on_var(
    &mut self,
    callback: impl Fn(&str, usize, &EvalContext<'_, '_, '_, '_, '_, '_, '_>) -> Result<Option<Dynamic>, Box<EvalAltResult>> + SendSync + 'static
) -> &mut Self

Provide a callback that will be invoked before each variable access.

Return Value of Callback

Return Ok(None) to continue with normal variable access.
Return Ok(Some(Dynamic)) as the variable’s value.

Errors in Callback

Return Err(...) if there is an error.

Example

use rhai::Engine;

let mut engine = Engine::new();

// Register a variable resolver.
engine.on_var(|name, _, _| {
    match name {
        "MYSTIC_NUMBER" => Ok(Some(42_i64.into())),
        _ => Ok(None)
    }
});

engine.eval::<i64>("MYSTIC_NUMBER")?;

pub fn on_progress(
    &mut self,
    callback: impl Fn(u64) -> Option<Dynamic> + SendSync + 'static
) -> &mut Self

Register a callback for script evaluation progress.

Example

use rhai::Engine;

let result = Arc::new(RwLock::new(0_u64));
let logger = result.clone();

let mut engine = Engine::new();

engine.on_progress(move |ops| {
    if ops > 10000 {
        Some("Over 10,000 operations!".into())
    } else if ops % 800 == 0 {
        *logger.write().unwrap() = ops;
        None
    } else {
        None
    }
});

engine.consume("for x in range(0, 50000) {}")
    .expect_err("should error");

assert_eq!(*result.read().unwrap(), 9600);

pub fn on_print(
    &mut self,
    callback: impl Fn(&str) + SendSync + 'static
) -> &mut Self

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

Example

use rhai::Engine;

let result = Arc::new(RwLock::new(String::new()));

let mut engine = Engine::new();

// Override action of 'print' function
let logger = result.clone();
engine.on_print(move |s| logger.write().unwrap().push_str(s));

engine.consume("print(40 + 2);")?;

assert_eq!(*result.read().unwrap(), "42");

pub fn on_debug(
    &mut self,
    callback: impl Fn(&str, Option<&str>, Position) + SendSync + 'static
) -> &mut Self

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

Example

use rhai::Engine;

let result = Arc::new(RwLock::new(String::new()));

let mut engine = Engine::new();

// Override action of 'print' function
let logger = result.clone();
engine.on_debug(move |s, src, pos| logger.write().unwrap().push_str(
                    &format!("{} @ {:?} > {}", src.unwrap_or("unknown"), pos, s)
               ));

let mut ast = engine.compile(r#"let x = "hello"; debug(x);"#)?;
ast.set_source("world");
engine.consume_ast(&ast)?;

assert_eq!(*result.read().unwrap(), r#"world @ 1:18 > "hello""#);

impl Engine

pub fn set_optimization_level(
    &mut self,
    optimization_level: OptimizationLevel
) -> &mut Self

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

Not available under no_optimize.

pub fn optimization_level(&self) -> OptimizationLevel

The current optimization level. It controls whether and how the Engine will optimize an AST after compilation.

Not available under no_optimize.

pub fn enable_doc_comments(&mut self, enable: bool) -> &mut Self

Enable/disable doc-comments.

pub fn set_max_call_levels(&mut self, levels: usize) -> &mut Self

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

Not available under unchecked or no_function.

pub fn max_call_levels(&self) -> usize

The maximum levels of function calls allowed for a script.

Not available under unchecked or no_function.

pub fn set_max_operations(&mut self, operations: u64) -> &mut Self

Set the maximum number of operations allowed for a script to run to avoid consuming too much resources (0 for unlimited).

Not available under unchecked.

pub fn max_operations(&self) -> u64

The maximum number of operations allowed for a script to run (0 for unlimited).

Not available under unchecked.

pub fn set_max_modules(&mut self, modules: usize) -> &mut Self

Set the maximum number of imported modules allowed for a script.

Not available under unchecked or no_module.

pub fn max_modules(&self) -> usize

The maximum number of imported modules allowed for a script.

Not available under unchecked or no_module.

pub fn set_max_expr_depths(
    &mut self,
    max_expr_depth: usize,
    max_function_expr_depth: usize
) -> &mut Self

Set the depth limits for expressions (0 for unlimited).

Not available under unchecked.

pub fn max_expr_depth(&self) -> usize

The depth limit for expressions (0 for unlimited).

Not available under unchecked.

pub fn max_function_expr_depth(&self) -> usize

The depth limit for expressions in functions (0 for unlimited).

Not available under unchecked or no_function.

pub fn set_max_string_size(&mut self, max_size: usize) -> &mut Self

Set the maximum length of strings (0 for unlimited).

Not available under unchecked.

pub fn max_string_size(&self) -> usize

The maximum length of strings (0 for unlimited).

Not available under unchecked.

pub fn set_max_array_size(&mut self, max_size: usize) -> &mut Self

Set the maximum length of arrays (0 for unlimited).

Not available under unchecked or no_index.

pub fn max_array_size(&self) -> usize

The maximum length of arrays (0 for unlimited).

Not available under unchecked or no_index.

pub fn set_max_map_size(&mut self, max_size: usize) -> &mut Self

Set the maximum size of object maps (0 for unlimited).

Not available under unchecked or no_object.

pub fn max_map_size(&self) -> usize

The maximum size of object maps (0 for unlimited).

Not available under unchecked or no_object.

pub fn set_module_resolver(
    &mut self,
    resolver: impl ModuleResolver + 'static
) -> &mut Self

Set the module resolution service used by the Engine.

Not available under no_module.

pub fn disable_symbol(&mut self, symbol: impl Into<String>) -> &mut Self

Disable a particular keyword or operator in the language.

Examples

The following will raise an error during parsing because the if keyword is disabled and is recognized as a reserved symbol!

use rhai::Engine;

let mut engine = Engine::new();

engine.disable_symbol("if");    // disable the 'if' keyword

engine.compile("let x = if true { 42 } else { 0 };")?;
//                      ^ 'if' is rejected as a reserved symbol

The following will raise an error during parsing because the += operator is disabled.

use rhai::Engine;

let mut engine = Engine::new();

engine.disable_symbol("+=");    // disable the '+=' operator

engine.compile("let x = 42; x += 1;")?;
//                            ^ unknown operator

pub fn register_custom_operator(
    &mut self,
    keyword: impl AsRef<str> + Into<String>,
    precedence: u8
) -> Result<&mut Self, String>

Register a custom operator with a precedence into the language.

The operator must be a valid identifier (i.e. it cannot be a symbol).

The precedence cannot be zero.

Example

use rhai::Engine;

let mut engine = Engine::new();

// Register a custom operator called 'foo' and give it
// a precedence of 160 (i.e. between +|- and *|/).
engine.register_custom_operator("foo", 160).unwrap();

// Register a binary function named 'foo'
engine.register_fn("foo", |x: i64, y: i64| (x * y) - (x + y));

assert_eq!(
    engine.eval_expression::<i64>("1 + 2 * 3 foo 4 - 5 / 6")?,
    15
);

impl Engine

pub fn register_custom_syntax<S: AsRef<str> + Into<Identifier>>(
    &mut self,
    keywords: &[S],
    new_vars: isize,
    func: impl Fn(&mut EvalContext<'_, '_, '_, '_, '_, '_, '_>, &[Expression<'_>]) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static
) -> Result<&mut Self, ParseError>

Register a custom syntax with the Engine.

• keywords holds a slice of strings that define the custom syntax.
• new_vars is the number of new variables declared by this custom syntax, or the number of variables removed (if negative).
• func is the implementation function.

Notes

If new_vars is positive, then a number of new variables are expected to be pushed into the current Scope.

If new_vars is negative, then it is expected that only the top new_vars variables in the current Scope will be popped. Do not randomly remove variables.

pub fn register_custom_syntax_raw(
    &mut self,
    key: impl Into<Identifier>,
    parse: impl Fn(&[ImmutableString], &str) -> Result<Option<ImmutableString>, ParseError> + SendSync + 'static,
    new_vars: isize,
    func: impl Fn(&mut EvalContext<'_, '_, '_, '_, '_, '_, '_>, &[Expression<'_>]) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static
) -> &mut Self

Register a custom syntax with the Engine.

WARNING - Low Level API

This function is very low level.

• new_vars is the number of new variables declared by this custom syntax, or the number of variables removed (if negative).
• parse is the parsing function.
• func is the implementation function.

All custom keywords must be manually registered via Engine::register_custom_operator. Otherwise, custom keywords won’t be recognized.

impl Engine

pub fn lex<'a>(
    &'a self,
    input: impl IntoIterator<Item = &'a &'a str>
) -> TokenIterator<'a>

(INTERNALS) Tokenize an input text stream. Exported under the internals feature only.

pub fn lex_with_map<'a>(
    &'a self,
    input: impl IntoIterator<Item = &'a &'a str>,
    map: fn(_: Token) -> Token
) -> TokenIterator<'a>

(INTERNALS) Tokenize an input text stream with a mapping function. Exported under the internals feature only.

impl Engine

pub fn gen_fn_metadata_with_ast_to_json(
    &self,
    _ast: &AST,
    include_global: bool
) -> Result<String>

(METADATA) Generate a list of all functions (including those defined in an AST) in JSON format. Available under the metadata feature only.

Functions from the following sources are included:

1. Functions defined in an AST
2. Functions registered into the global namespace
3. Functions in static modules
4. Functions in global modules (optional)

pub fn gen_fn_metadata_to_json(&self, include_global: bool) -> Result<String>

Generate a list of all functions in JSON format. Available only under the metadata feature.

Functions from the following sources are included:

1. Functions registered into the global namespace
2. Functions in static modules
3. Functions in global modules (optional)

Trait Implementations

impl Debug for Engine

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Engine

fn default() -> Self

Returns the “default value” for a type.

impl<RET: Variant + Clone> Func<(), RET> for Engine

type Output = Box<dyn Fn() -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<A: Variant + Clone, B: Variant + Clone, C: Variant + Clone, D: Variant + Clone, E: Variant + Clone, F: Variant + Clone, G: Variant + Clone, H: Variant + Clone, J: Variant + Clone, K: Variant + Clone, L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<B: Variant + Clone, C: Variant + Clone, D: Variant + Clone, E: Variant + Clone, F: Variant + Clone, G: Variant + Clone, H: Variant + Clone, J: Variant + Clone, K: Variant + Clone, L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<C: Variant + Clone, D: Variant + Clone, E: Variant + Clone, F: Variant + Clone, G: Variant + Clone, H: Variant + Clone, J: Variant + Clone, K: Variant + Clone, L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<D: Variant + Clone, E: Variant + Clone, F: Variant + Clone, G: Variant + Clone, H: Variant + Clone, J: Variant + Clone, K: Variant + Clone, L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<E: Variant + Clone, F: Variant + Clone, G: Variant + Clone, H: Variant + Clone, J: Variant + Clone, K: Variant + Clone, L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<F: Variant + Clone, G: Variant + Clone, H: Variant + Clone, J: Variant + Clone, K: Variant + Clone, L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<G: Variant + Clone, H: Variant + Clone, J: Variant + Clone, K: Variant + Clone, L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<H: Variant + Clone, J: Variant + Clone, K: Variant + Clone, L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<J: Variant + Clone, K: Variant + Clone, L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<K: Variant + Clone, L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(K, L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<L: Variant + Clone, M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(L, M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(L, M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<M: Variant + Clone, N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(M, N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(M, N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<N: Variant + Clone, P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(N, P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(N, P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(P, Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(P, Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(Q, R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(Q, R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(R, S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(R, S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(S, T, U, V), RET> for Engine

type Output = Box<dyn Fn(S, T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(T, U, V), RET> for Engine

type Output = Box<dyn Fn(T, U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(U, V), RET> for Engine

type Output = Box<dyn Fn(U, V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.

impl<V: Variant + Clone, RET: Variant + Clone> Func<(V,), RET> for Engine

type Output = Box<dyn Fn(V) -> Result<RET, Box<EvalAltResult>>>

fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output

Create a Rust closure from an AST.

fn create_from_script(
    self,
    script: &str,
    entry_point: &str
) -> Result<Self::Output, ParseError>

Create a Rust closure from a script.