Crate quad_compat_rhai

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+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.

Crate quad_compat_rhaiCopy item path