Crate quad_compat_rhai

Source
Expand description

§Rhai - embedded scripting for Rust

Rhai logo

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+Rust and a simple Rust interface.

§A Quick Example

§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))

§The Rust part

use quad_compat_rhai::{Engine, EvalAltResult};

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§

module_resolvers
Module containing all built-in module resolvers available to Rhai. Module containing all built-in module resolvers.
packages
Module containing all built-in packages available to Rhai, plus facilities to define custom packages.
plugin
Module defining macros for developing plugins.
serde
(serde) Serialization and deserialization support for serde. Exported under the serde feature only.

Macros§

combine_with_exported_module
Macro to combine a plugin module into an existing module.
def_package
Macro that makes it easy to define a package (which is basically a shared module) and register functions into it.
exported_module
Macro to generate a Rhai Module from a plugin module defined via #[export_module].
register_exported_fn
Macro to register a plugin function (defined via #[export_fn]) into an Engine.
set_exported_fn
Macro to register a plugin function into a Rhai Module.
set_exported_global_fn
Macro to register a plugin function into a Rhai Module and expose it globally.

Structs§

AST
Compiled AST (abstract syntax tree) of a Rhai script.
BinaryExpr
(internals) A binary expression. Exported under the internals feature only.
CustomExpr
(internals) A custom syntax expression. Exported under the internals feature only.
Dynamic
Dynamic type containing any value.
DynamicReadLock
(internals) Lock guard for reading a Dynamic. Exported under the internals feature only.
DynamicWriteLock
(internals) Lock guard for writing a Dynamic. Exported under the internals feature only.
Engine
Rhai main scripting engine.
EvalContext
Context of a script evaluation process.
EvalState
(internals) A type that holds all the current states of the Engine. Exported under the internals feature only.
Expression
An expression sub-tree in an AST.
FloatWrapper
A type that wraps a floating-point number and implements Hash.
FnCallExpr
(internals) A function call. Exported under the internals feature only.
FnCallHashes
(internals) A set of function call hashes. Exported under the internals feature only.
FnPtr
A general function pointer, which may carry additional (i.e. curried) argument values to be passed onto a function during a call.
FnResolutionCacheEntry
(internals) An entry in a function resolution cache. Exported under the internals feature only.
Ident
(internals) An identifier containing a name and a position. Exported under the internals feature only.
IdentifierBuilder
(internals) A factory of identifiers from text strings. Exported under the internals feature only.
ImmutableString
The system immutable string type.
Imports
(internals) A stack of imported modules plus mutable runtime global states. Exported under the internals feature only.
Locked
Alias to RefCell or RwLock depending on the sync feature flag. Synchronized shared object. A mutable memory location with dynamically checked borrow rules
Module
A module which may contain variables, sub-modules, external Rust functions, and/or script-defined functions.
MultiInputsStream
(internals) A type that implements the InputStream trait. Exported under the internals feature only.
NamespaceRef
(internals) A chain of module names to namespace-qualify a variable or function call. Exported under the internals feature only.
NativeCallContext
Context of a native Rust function call.
OpAssignment
(internals) An op-assignment operator. Exported under the internals feature only.
OptionFlags
A type that holds a configuration option with bit-flags. Exported under the internals feature only.
ParseError
Error when parsing a script.
ParseState
(internals) A type that encapsulates the current state of the parser. Exported under the internals feature only.
Position
A location (line number + character position) in the input script.
Scope
Type containing information about the current scope. Useful for keeping state between Engine evaluation runs.
ScriptFnDef
(internals) A type containing information on a scripted function. Exported under the internals feature only.
ScriptFnMetadata
A type containing the metadata of a script-defined function.
Shared
Alias to Rc or Arc depending on the sync feature flag. Immutable reference-counted container. A single-threaded reference-counting pointer. ‘Rc’ stands for ‘Reference Counted’.
StmtBlock
(internals) A scoped block of statements. Exported under the internals feature only.
TokenIterator
(internals) An iterator on a Token stream. Exported under the internals feature only.
TokenizeState
(internals) State of the tokenizer. Exported under the internals feature only.
TokenizerControlBlock
(internals) A type containing commands to control the tokenizer.

Enums§

ASTNode
(internals) An AST node, consisting of either an Expr or a Stmt. Exported under the internals feature only.
AccessMode
(internals) Modes of access. Exported under the internals feature only.
EvalAltResult
Evaluation result.
Expr
(internals) An expression sub-tree. Exported under the internals feature only.
FnAccess
A type representing the access mode of a function.
FnNamespace
A type representing the namespace of a function.
LexError
(internals) Error encountered when tokenizing the script text. Exported under the internals feature only.
OptimizationLevel
Level of optimization performed.
ParseErrorType
Type of error encountered when parsing a script.
Stmt
(internals) A statement. Exported under the internals feature only.
Token
(internals) A Rhai language token. Exported under the internals feature only.

Constants§

AST_OPTION_BREAK_OUT
(internals) The AST node breaks out of normal control flow. Exported under the internals feature only.
AST_OPTION_CONSTANT
(internals) The AST node is constant. Exported under the internals feature only.
AST_OPTION_NEGATED
(internals) The AST node is in negated mode. Exported under the internals feature only.
AST_OPTION_NONE
(internals) No options for the AST node. Exported under the internals feature only.
AST_OPTION_PUBLIC
(internals) The AST node is public. Exported under the internals feature only.
OP_CONTAINS
Standard method function for containment testing. The in operator is implemented as a call to this method.
OP_EQUALS
Standard equality comparison operator.
OP_EXCLUSIVE_RANGE
Standard exclusive range operator.
OP_INCLUSIVE_RANGE
Standard inclusive range operator.

Traits§

Func
Trait to create a Rust closure from a script.
FuncArgs
Trait that parses arguments to a function call.
InputStream
(internals) Trait that encapsulates a peekable character input stream. Exported under the internals feature only.
ModuleResolver
Trait that encapsulates a module resolution service.
RegisterNativeFunction
Trait to register custom Rust functions.
Variant
(internals) Trait to represent any type. Exported under the internals feature only.

Functions§

get_next_token
(internals) Get the next token from the stream. Exported under the internals feature only.
parse_string_literal
(internals) Parse a string literal ended by termination_char. Exported under the internals feature only.

Type Aliases§

Array
Variable-sized array of Dynamic values. Not available under no_index.
Blob
Variable-sized array of u8 values (byte array). Not available under no_index.
ExclusiveRange
FLOAT
The system floating-point type. It is defined as f64. Not available under no_float.
FnResolutionCache
(internals) A function resolution cache. Exported under the internals feature only.
INT
The system integer type. It is defined as i64.
Identifier
An identifier in Rhai. SmartString is used because most identifiers are ASCII and short, fewer than 23 characters, so they can be stored inline.
InclusiveRange
Map
Hash map of Dynamic values with SmartString keys. Not available under no_object.
StaticVec
(internals) Alias to smallvec::SmallVec<[T; 3]>, which is a Vec backed by a small, inline, fixed-size array when there are ≤ 3 items stored. Exported under the internals feature only.
TokenizerControl
(internals) A shared object that allows control of the tokenizer from outside.

Attribute Macros§

export_fn
Attribute, when put on a Rust function, turns it into a plugin function.
export_module
Attribute, when put on a Rust module, turns it into a plugin module.