rhai/README.md

419 lines
9.7 KiB
Markdown
Raw Normal View History

2016-02-29 22:43:45 +01:00
# Rhai - embedded scripting for Rust
2016-04-14 03:52:12 +02:00
Rhai is an embedded scripting language for Rust that gives you a safe and easy way to add scripting to your applications.
2016-03-02 20:53:12 +01:00
2016-03-03 15:59:53 +01:00
Rhai's current feature set:
2016-03-03 16:10:08 +01:00
* Easy integration with Rust functions and data types
2016-03-03 15:59:53 +01:00
* Fairly efficient (1 mil iterations in 0.75 sec on my 5 year old laptop)
2016-03-04 14:08:34 +01:00
* Low compile-time overhead (~0.6 sec debug/~3 sec release for script runner app)
2016-03-03 16:14:11 +01:00
* Easy-to-use language based on JS+Rust
2016-03-03 15:59:53 +01:00
* Support for overloaded functions
* No additional dependencies
* No unsafe code
**Note:** Currently, the version is 0.8.1, so the language and APIs may change before they stabilize.*
2016-03-14 16:31:24 +01:00
## Installation
You can install Rhai using crates by adding this line to your dependences:
2017-12-11 07:32:12 +01:00
```toml
2016-03-14 16:31:24 +01:00
[dependencies]
rhai = "0.8.1"
2016-03-14 16:31:24 +01:00
```
## Related
2016-03-03 16:00:29 +01:00
2016-03-04 14:13:57 +01:00
Other cool projects to check out:
* [ChaiScript](http://chaiscript.com/) - A strong inspiration for Rhai. An embedded scripting language for C++ that I helped created many moons ago, now being lead by my cousin.
* You can also check out the list of [scripting languages for Rust](https://github.com/rust-unofficial/awesome-rust#scripting) on [awesome-rust](https://github.com/rust-unofficial/awesome-rust)
2016-03-04 14:13:57 +01:00
## Examples
The repository contains several examples in the `examples` folder:
- `arrays_and_structs` demonstrates registering a new type to Rhai and the usage of arrays on it
- `custom_types_and_methods` shows how to register a type and methods for it
- `hello` simple example that evaluates an expression and prints the result
- `reuse_scope` evaluates two pieces of code in separate runs, but using a common scope
- `rhai_runner` runs each filename passed to it as a Rhai script
- `simple_fn` shows how to register a Rust function to a Rhai engine
2017-10-15 17:52:02 +02:00
- `repl` a simple REPL, see source code for what it can do at the moment
Examples can be run with the following command:
```bash
cargo run --example name
```
## Example Scripts
We also have a few examples scripts that showcase Rhai's features, all stored in the `scripts` folder:
- `array.rhai` - arrays in Rhai
- `assignment.rhai` - variable declarations
- `comments.rhai` - just comments
- `function_decl1.rhai` - a function without parameters
- `function_decl2.rhai` - a function with two parameters
- `function_decl3.rhai` - a function with many parameters
- `if1.rhai` - if example
- `loop.rhai` - endless loop in Rhai, this example emulates a do..while cycle
- `op1.rhai` - just a simple addition
- `op2.rhai` - simple addition and multiplication
- `op3.rhai` - change evaluation order with parenthesis
- `speed_test.rhai` - a simple program to measure the speed of Rhai's interpreter
- `string.rhai`- string operations
- `while.rhai` - while loop
To run the scripts, you can either make your own tiny program, or make use of the `rhai_runner`
example program:
```bash
cargo run --example rhai_runner scripts/any_script.rhai
```
2016-03-31 16:01:58 +02:00
# Hello world
2016-04-14 03:52:12 +02:00
To get going with Rhai, you create an instance of the scripting engine and then run eval.
2016-02-29 22:43:45 +01:00
2017-11-04 11:18:56 +01:00
```rust
2016-03-03 17:07:45 +01:00
extern crate rhai;
use rhai::Engine;
2016-03-02 20:40:07 +01:00
2016-03-03 17:07:45 +01:00
fn main() {
let mut engine = Engine::new();
2016-04-14 03:52:12 +02:00
if let Ok(result) = engine.eval::<i64>("40 + 2") {
2016-03-26 21:45:24 +01:00
println!("Answer: {}", result); // prints 42
2016-03-03 17:07:45 +01:00
}
2016-03-02 20:40:07 +01:00
}
```
2016-03-31 16:01:58 +02:00
2016-03-31 16:06:39 +02:00
You can also evaluate a script file:
2017-11-04 11:18:56 +01:00
```rust
2016-04-14 03:52:12 +02:00
if let Ok(result) = engine.eval_file::<i64>("hello_world.rhai") { ... }
2016-03-31 16:06:39 +02:00
```
2016-03-31 16:01:58 +02:00
# Working with functions
2016-03-02 20:53:12 +01:00
Rhai's scripting engine is very lightweight. It gets its ability from the functions in your program. To call these functions, you need to register them with the scripting engine.
2017-11-04 11:18:56 +01:00
```rust
2016-03-03 17:07:45 +01:00
extern crate rhai;
use rhai::{Engine, RegisterFn};
2016-03-03 17:07:45 +01:00
2016-04-14 03:52:12 +02:00
fn add(x: i64, y: i64) -> i64 {
2016-03-02 20:53:12 +01:00
x + y
}
fn main() {
let mut engine = Engine::new();
2016-03-26 21:42:54 +01:00
engine.register_fn("add", add);
2016-04-14 03:52:12 +02:00
if let Ok(result) = engine.eval::<i64>("add(40, 2)") {
2016-03-26 21:45:24 +01:00
println!("Answer: {}", result); // prints 42
2016-03-02 20:53:12 +01:00
}
}
```
2016-03-02 20:40:07 +01:00
2016-03-31 16:01:58 +02:00
# Working with generic functions
2016-03-02 20:53:12 +01:00
Generic functions can be used in Rhai, but you'll need to register separate instances for each concrete type:
2017-11-04 11:18:56 +01:00
```rust
2016-03-03 17:07:45 +01:00
use std::fmt::Display;
extern crate rhai;
use rhai::{Engine, RegisterFn};
2016-03-03 17:07:45 +01:00
2016-03-02 20:53:12 +01:00
fn showit<T: Display>(x: &mut T) -> () {
println!("{}", x)
}
fn main() {
let mut engine = Engine::new();
2016-04-14 03:52:12 +02:00
engine.register_fn("print", showit as fn(x: &mut i64)->());
2016-03-26 21:42:54 +01:00
engine.register_fn("print", showit as fn(x: &mut bool)->());
engine.register_fn("print", showit as fn(x: &mut String)->());
2016-03-02 20:53:12 +01:00
}
```
2016-03-04 14:10:53 +01:00
You can also see in this example how you can register multiple functions (or in this case multiple instances of the same function) to the same name in script. This gives you a way to overload functions and call the correct one, based on the types of the arguments, from your script.
2016-03-03 16:14:11 +01:00
2016-03-31 16:01:58 +02:00
# Custom types and methods
2016-03-02 20:40:07 +01:00
2016-03-02 21:08:35 +01:00
Here's an more complete example of working with Rust. First the example, then we'll break it into parts:
2016-03-02 20:53:12 +01:00
2017-11-04 11:18:56 +01:00
```rust
2016-03-03 17:07:45 +01:00
extern crate rhai;
use rhai::{Engine, RegisterFn};
2016-03-03 17:07:45 +01:00
2016-03-10 22:48:56 +01:00
#[derive(Clone)]
2016-03-02 20:40:07 +01:00
struct TestStruct {
2016-04-14 03:52:12 +02:00
x: i64
2016-03-02 20:40:07 +01:00
}
impl TestStruct {
fn update(&mut self) {
self.x += 1000;
}
fn new() -> TestStruct {
TestStruct { x: 1 }
}
}
2016-03-03 17:07:45 +01:00
fn main() {
let mut engine = Engine::new();
2016-03-02 20:40:07 +01:00
2016-03-03 17:07:45 +01:00
engine.register_type::<TestStruct>();
2016-03-02 20:40:07 +01:00
2016-03-26 21:42:54 +01:00
engine.register_fn("update", TestStruct::update);
engine.register_fn("new_ts", TestStruct::new);
2016-03-02 20:40:07 +01:00
2017-10-02 18:46:35 +02:00
if let Ok(result) = engine.eval::<TestStruct>("let x = new_ts(); x.update(); x") {
2016-03-03 17:07:45 +01:00
println!("result: {}", result.x); // prints 1001
}
2016-03-02 20:40:07 +01:00
}
```
First, for each type we use with the engine, we need to be able to Clone. This allows the engine to pass by value and still keep its own state.
2017-11-04 11:18:56 +01:00
```rust
2016-03-10 22:48:56 +01:00
#[derive(Clone)]
2016-03-02 20:40:07 +01:00
struct TestStruct {
2016-04-14 03:52:12 +02:00
x: i64
2016-03-02 20:40:07 +01:00
}
```
Next, we create a few methods that we'll later use in our scripts. Notice that we register our custom type with the engine.
2017-11-04 11:18:56 +01:00
```rust
2016-03-02 20:40:07 +01:00
impl TestStruct {
fn update(&mut self) {
self.x += 1000;
}
fn new() -> TestStruct {
TestStruct { x: 1 }
}
}
let mut engine = Engine::new();
engine.register_type::<TestStruct>();
```
To use methods and functions with the engine, we need to register them. There are some convenience functions to help with this. Below I register update and new with the engine.
2016-03-02 20:53:12 +01:00
*Note: the engine follows the convention that methods use a &mut first parameter so that invoking methods can update the value in memory.*
2016-03-02 20:40:07 +01:00
2017-11-04 11:18:56 +01:00
```rust
2016-03-26 21:42:54 +01:00
engine.register_fn("update", TestStruct::update);
engine.register_fn("new_ts", TestStruct::new);
2016-03-02 20:40:07 +01:00
```
Finally, we call our script. The script can see the function and method we registered earlier. We need to get the result back out from script land just as before, this time casting to our custom struct type.
2017-11-04 11:18:56 +01:00
```rust
2017-10-02 18:46:35 +02:00
if let Ok(result) = engine.eval::<TestStruct>("let x = new_ts(); x.update(); x") {
2016-03-02 20:40:07 +01:00
println!("result: {}", result.x); // prints 1001
}
```
2016-03-04 14:27:06 +01:00
2016-03-31 16:01:58 +02:00
# Getters and setters
2016-03-10 22:25:03 +01:00
2016-04-14 03:52:12 +02:00
Similarly, you can work with members of your custom types. This works by registering a 'get' or a 'set' function for working with your struct.
2016-03-10 22:25:03 +01:00
For example:
2017-11-04 11:18:56 +01:00
```rust
2016-03-10 22:25:03 +01:00
#[derive(Clone)]
struct TestStruct {
2016-04-14 03:52:12 +02:00
x: i64
2016-03-10 22:25:03 +01:00
}
impl TestStruct {
2016-04-14 03:52:12 +02:00
fn get_x(&mut self) -> i64 {
2016-03-10 22:25:03 +01:00
self.x
}
2016-04-14 03:52:12 +02:00
fn set_x(&mut self, new_x: i64) {
2016-03-10 22:25:03 +01:00
self.x = new_x;
}
fn new() -> TestStruct {
TestStruct { x: 1 }
}
}
let mut engine = Engine::new();
engine.register_type::<TestStruct>();
2016-03-26 21:42:54 +01:00
engine.register_get_set("x", TestStruct::get_x, TestStruct::set_x);
engine.register_fn("new_ts", TestStruct::new);
2016-03-10 22:25:03 +01:00
2017-10-02 18:46:35 +02:00
if let Ok(result) = engine.eval::<i64>("let a = new_ts(); a.x = 500; a.x") {
2016-03-10 22:25:03 +01:00
println!("result: {}", result);
}
```
2016-03-31 16:01:58 +02:00
# Maintaining state
2016-03-04 14:27:06 +01:00
By default, Rhai treats each engine invocation as a fresh one, persisting only the functions that have been defined but no top-level state. This gives each one a fairly clean starting place. Sometimes, though, you want to continue using the same top-level state from one invocation to the next.
In this example, we thread the same state through multiple invocations:
2017-11-04 11:18:56 +01:00
```rust
2016-03-04 14:27:06 +01:00
extern crate rhai;
use rhai::{Engine, Scope};
fn main() {
let mut engine = Engine::new();
let mut scope: Scope = Vec::new();
2017-10-02 18:46:35 +02:00
if let Ok(_) = engine.eval_with_scope::<()>(&mut scope, "let x = 4 + 5") { } else { assert!(false); }
2016-03-04 14:27:06 +01:00
2016-04-14 03:52:12 +02:00
if let Ok(result) = engine.eval_with_scope::<i64>(&mut scope, "x") {
2016-03-04 14:27:06 +01:00
println!("result: {}", result);
}
}
```
2016-03-10 22:25:03 +01:00
2016-03-31 16:03:03 +02:00
# Rhai Language guide
2016-03-31 15:59:54 +02:00
## Variables
2017-11-04 11:18:56 +01:00
```rust
2017-10-02 18:46:35 +02:00
let x = 3;
2016-03-31 15:59:54 +02:00
```
## Operators
2017-11-04 11:18:56 +01:00
```rust
2017-10-02 18:46:35 +02:00
let x = (1 + 2) * (6 - 4) / 2;
2016-03-31 15:59:54 +02:00
```
## If
2017-11-04 11:18:56 +01:00
```rust
2016-04-14 03:52:12 +02:00
if true {
2016-03-31 15:59:54 +02:00
print("it's true!");
}
else {
print("It's false!");
}
```
## While
2017-11-04 11:18:56 +01:00
```rust
2017-10-02 18:46:35 +02:00
let x = 10;
2016-04-14 03:52:12 +02:00
while x > 0 {
2016-03-31 15:59:54 +02:00
print(x);
if x == 5 {
break;
}
x = x - 1;
}
```
## Loop
```rust
let x = 10;
loop {
print(x);
x = x - 1;
if x == 0 { break; }
}
```
2016-03-31 15:59:54 +02:00
## Functions
Rhai supports defining functions in script:
2017-11-04 11:18:56 +01:00
```rust
2016-03-31 15:59:54 +02:00
fn add(x, y) {
return x + y;
}
print(add(2, 3))
```
Just like in Rust, you can also use an implicit return.
2017-11-04 11:18:56 +01:00
```rust
2016-03-31 15:59:54 +02:00
fn add(x, y) {
x + y
}
print(add(2, 3))
```
2016-04-14 03:52:12 +02:00
## Arrays
2016-03-31 15:59:54 +02:00
You can create arrays of values, and then access them with numeric indices.
2017-11-04 11:18:56 +01:00
```rust
2017-10-02 18:46:35 +02:00
let y = [1, 2, 3];
2016-04-14 03:52:12 +02:00
y[1] = 5;
2016-03-31 15:59:54 +02:00
print(y[1]);
```
## Members and methods
2017-11-04 11:18:56 +01:00
```rust
2017-10-02 18:46:35 +02:00
let a = new_ts();
2016-03-31 15:59:54 +02:00
a.x = 500;
a.update();
```
2016-04-14 03:52:12 +02:00
## Strings and Chars
2017-11-04 11:18:56 +01:00
```rust
2017-10-02 18:46:35 +02:00
let name = "Bob";
let middle_initial = 'C';
2016-04-14 03:52:12 +02:00
```
2016-03-31 15:59:54 +02:00
## Comments
```rust
let /* intruder comment */ name = "Bob";
// This is a very important comment
/* This comment spans
multiple lines, so it
only makes sense that
it is even more important */
/* Fear not, Rhai satisfies all your nesting
needs with nested comments:
/*/*/*/*/**/*/*/*/*/
*/
```
2017-11-04 11:18:56 +01:00
## Unary operators
```rust
let number = -5;
number = -5 - +5;
let booly = !true;
```
## Compound assignment operators
2017-11-04 11:18:56 +01:00
```rust
let number = 5;
number += 4;
number -= 3;
number *= 2;
number /= 1;
number %= 3;
number <<= 2;
number >>= 1;
```
The `+=` operator can also be used to build strings:
```rust
let my_str = "abc";
my_str += "ABC";
my_str == "abcABC"
```