Crate rhai[−][src]
Expand description
Rhai - embedded scripting for Rust
Rhai is a tiny, simple and fast embedded scripting language for Rust that gives you a safe and easy way to add scripting to your applications. It provides a familiar syntax based on JavaScript and Rust and a simple Rust interface. Here is a quick example.
First, the contents of my_script.rhai
:
// Brute force factorial function
fn factorial(x) {
if x == 1 { return 1; }
x * factorial(x - 1)
}
// Calling an external function 'compute'
compute(factorial(10))
And the Rust part:
use rhai::{Engine, EvalAltResult, RegisterFn};
fn main() -> Result<(), Box<EvalAltResult>>
{
// Define external function
fn compute_something(x: i64) -> bool {
(x % 40) == 0
}
// Create scripting engine
let mut engine = Engine::new();
// Register external function as 'compute'
engine.register_fn("compute", compute_something);
assert_eq!(
// Evaluate the script, expects a 'bool' return
engine.eval_file::<bool>("my_script.rhai".into())?,
true
);
Ok(())
}
Documentation
See The Rhai Book for details on the Rhai scripting engine and language.
Modules
Re-export module resolvers.
Module containing all built-in packages available to Rhai, plus facilities to define custom packages.
Module defining macros for developing plugins.
Macros
Macro to combine a plugin module into an existing module.
Macro that makes it easy to define a package (which is basically a shared module) and register functions into it.
Macro to generate a Rhai Module
from a plugin module defined via #[export_module]
.
Macro to register a plugin function (defined via #[export_fn]
) into an Engine
.
Macro to register a plugin function into a Rhai Module
.
Macro to register a plugin function into a Rhai Module
and expose it globally.
Structs
Compiled AST (abstract syntax tree) of a Rhai script.
(INTERNALS) A binary expression.
Exported under the internals
feature only.
(INTERNALS) A custom syntax definition.
Exported under the internals
feature only.
Dynamic type containing any value.
Rhai main scripting engine.
Context of a script evaluation process.
(INTERNALS) A type that holds all the current states of the Engine.
Exported under the internals
feature only.
An expression sub-tree in an AST
.
(INTERNALS) A function call.
Exported under the internals
feature only.
A general function pointer, which may carry additional (i.e. curried) argument values to be passed onto a function during a call.
An identifier containing a string name and a position.
An identifier containing an immutable name and a position.
The system immutable string type.
(INTERNALS) A stack of imported modules.
Exported under the internals
feature only.
(INTERNALS) A type containing all the limits imposed by the Engine
.
Exported under the internals
feature only.
A module which may contain variables, sub-modules, external Rust functions, and/or script-defined functions.
(INTERNALS) A chain of module names to namespace-qualify a variable or function call.
Exported under the internals
feature only.
Context of native Rust function call.
Error when parsing a script.
A location (line number + character position) in the input script.
Type containing information about the current scope.
Useful for keeping state between Engine
evaluation runs.
(INTERNALS) A type containing information on a scripted function.
Exported under the internals
feature only.
(INTERNALS) State of the tokenizer.
Exported under the internals
feature only.
Enums
Evaluation result.
(INTERNALS) An expression sub-tree.
Exported under the internals
feature only.
A type representing the access mode of a function.
A type representing the namespace of a function.
(INTERNALS) Error encountered when tokenizing the script text.
Exported under the internals
feature only.
Level of optimization performed.
Type of error encountered when parsing a script.
(INTERNALS) A type encapsulating the mode of a return
/throw
statement.
Exported under the internals
feature only.
(INTERNALS) A statement.
Exported under the internals
feature only.
(INTERNALS) A Rhai language token.
Exported under the internals
feature only.
Traits
Trait to create a Rust closure from a script.
(INTERNALS) Trait that encapsulates a peekable character input stream.
Exported under the internals
feature only.
Trait that encapsulates a module resolution service.
Trait to register custom functions with the Engine
.
Trait to register fallible custom functions returning Result<Dynamic, Box<EvalAltResult>>
with the Engine
.
Functions
(INTERNALS) Calculate a u64
hash key from a namespace-qualified function name and parameter types.
Exported under the internals
feature only.
(INTERNALS) Calculate a u64
hash key from a namespace-qualified function name
and the number of parameters, but no parameter types.
Exported under the internals
feature only.
(INTERNALS) Get the next token from the stream
.
Exported under the internals
feature only.
(INTERNALS) Parse a string literal wrapped by enclosing_char
.
Exported under the internals
feature only.
Type Definitions
Variable-sized array of Dynamic
values.
The system floating-point type. It is defined as f64
.
The system integer type. It is defined as i64
.
Hash map of Dynamic
values with ImmutableString
keys.
(INTERNALS) Alias to smallvec::SmallVec<[T; 4]>
,
which is a specialized Vec
backed by a small, fixed-size array when there are <= 4 items stored.
Exported under the internals
feature only.
Attribute Macros
Attribute, when put on a Rust function, turns it into a plugin function.
Attribute, when put on a Rust module, turns it into a plugin module.