[−][src]Struct rhai::Engine
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
Fields
id: String
A unique ID identifying this scripting Engine
.
Implementations
impl Engine
[src]
pub fn new() -> Self
[src]
Create a new Engine
pub fn new_raw() -> Self
[src]
Create a new Engine
with minimal built-in functions.
Use the load_package
method to load additional packages of functions.
impl Engine
[src]
Engine public API
pub fn register_raw_fn<T: Variant + Clone>(
&mut self,
name: &str,
arg_types: &[TypeId],
func: impl Fn(NativeCallContext<'_, '_, '_, '_>, &mut FnCallArgs<'_>) -> Result<T, Box<EvalAltResult>> + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
&mut self,
name: &str,
arg_types: &[TypeId],
func: impl Fn(NativeCallContext<'_, '_, '_, '_>, &mut FnCallArgs<'_>) -> Result<T, Box<EvalAltResult>> + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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 parameter value (i.e. cloning is cheap), use: args[n].clone().cast::<T>()
To access a parameter 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ⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, RegisterFn}; let mut engine = Engine::new(); // Register the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); // Use `register_fn` to register methods on the type. engine.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ⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
&mut self,
name: &str
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, RegisterFn}; let mut engine = Engine::new(); // Register the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); assert_eq!( engine.eval::<String>("let x = new_ts(); type_of(x)")?, "rust_out::TestStruct" ); // Register the custom type with a name. engine.register_type_with_name::<TestStruct>("Hello"); // Register methods on the type. engine.register_fn("new_ts", TestStruct::new); assert_eq!( engine.eval::<String>("let x = new_ts(); type_of(x)")?, "Hello" );
pub fn register_iterator<T>(&mut self) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
where
T: Variant + Clone + Iterator,
<T as Iterator>::Item: Variant + Clone,
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
T: Variant + Clone + Iterator,
<T as Iterator>::Item: Variant + Clone,
Register an iterator adapter for an iterable type with the Engine
.
This is an advanced feature.
pub fn register_get<T, U>(
&mut self,
name: &str,
callback: impl Fn(&mut T) -> U + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
where
T: Variant + Clone,
U: Variant + Clone,
[src]
&mut self,
name: &str,
callback: impl Fn(&mut T) -> U + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
T: Variant + Clone,
U: Variant + Clone,
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, RegisterFn}; let mut engine = Engine::new(); // Register the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); // Register a getter on a property (notice it doesn't have to be the same name). engine.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>(
&mut self,
name: &str,
callback: impl Fn(&mut T) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
&mut self,
name: &str,
callback: impl Fn(&mut T) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Register a getter function for a member of a registered type with the Engine
.
Returns Result<Dynamic, Box<EvalAltResult>>
.
The function signature must start with &mut self
and not &self
.
Example
use rhai::{Engine, Dynamic, EvalAltResult, RegisterFn}; #[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<Dynamic, Box<EvalAltResult>> { Ok(self.field.into()) } } let mut engine = Engine::new(); // Register the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); // Register a getter on a property (notice it doesn't have to be the same name). engine.register_get_result("xyz", TestStruct::get_field); assert_eq!(engine.eval::<i64>("let a = new_ts(); a.xyz")?, 1);
pub fn register_set<T, U>(
&mut self,
name: &str,
callback: impl Fn(&mut T, U) + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
where
T: Variant + Clone,
U: Variant + Clone,
[src]
&mut self,
name: &str,
callback: impl Fn(&mut T, U) + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
T: Variant + Clone,
U: Variant + Clone,
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, RegisterFn}; let mut engine = Engine::new(); // Register the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); // Register a setter on a property (notice it doesn't have to be the same name) engine.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, U>(
&mut self,
name: &str,
callback: impl Fn(&mut T, U) -> Result<(), Box<EvalAltResult>> + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
where
T: Variant + Clone,
U: Variant + Clone,
[src]
&mut self,
name: &str,
callback: impl Fn(&mut T, U) -> Result<(), Box<EvalAltResult>> + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
T: Variant + Clone,
U: Variant + Clone,
Register a setter function for a member of a registered type with the Engine
.
Returns Result<(), Box<EvalAltResult>>
.
Example
use rhai::{Engine, Dynamic, EvalAltResult, RegisterFn}; #[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 the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); // Register a setter on a property (notice it doesn't have to be the same name) engine.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, U>(
&mut self,
name: &str,
get_fn: impl Fn(&mut T) -> U + SendSync + 'static,
set_fn: impl Fn(&mut T, U) + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
where
T: Variant + Clone,
U: Variant + Clone,
[src]
&mut self,
name: &str,
get_fn: impl Fn(&mut T) -> U + SendSync + 'static,
set_fn: impl Fn(&mut T, U) + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
T: Variant + Clone,
U: Variant + Clone,
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, RegisterFn}; let mut engine = Engine::new(); // Register the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); // Register a getter and a setter on a property // (notice it doesn't have to be the same name) engine.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, X, U>(
&mut self,
callback: impl Fn(&mut T, X) -> U + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
where
T: Variant + Clone,
U: Variant + Clone,
X: Variant + Clone,
[src]
&mut self,
callback: impl Fn(&mut T, X) -> U + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
T: Variant + Clone,
U: Variant + Clone,
X: Variant + Clone,
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
or Map
.
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, RegisterFn}; let mut engine = Engine::new(); // Register the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); // Register an indexer. engine.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, X>(
&mut self,
callback: impl Fn(&mut T, X) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
where
T: Variant + Clone,
X: Variant + Clone,
[src]
&mut self,
callback: impl Fn(&mut T, X) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
T: Variant + Clone,
X: Variant + Clone,
Register an index getter for a custom type with the Engine
.
Returns Result<Dynamic, Box<EvalAltResult>>
.
The function signature must start with &mut self
and not &self
.
Panics
Panics if the type is Array
or Map
.
Indexers for arrays, object maps and strings cannot be registered.
Example
use rhai::{Engine, Dynamic, EvalAltResult, RegisterFn}; #[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<Dynamic, Box<EvalAltResult>> { Ok(self.fields[index as usize].into()) } } let mut engine = Engine::new(); // Register the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); // Register an indexer. engine.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, X, U>(
&mut self,
callback: impl Fn(&mut T, X, U) + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
where
T: Variant + Clone,
U: Variant + Clone,
X: Variant + Clone,
[src]
&mut self,
callback: impl Fn(&mut T, X, U) + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
T: Variant + Clone,
U: Variant + Clone,
X: Variant + Clone,
Register an index setter for a custom type with the Engine
.
Panics
Panics if the type is Array
or Map
.
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, RegisterFn}; let mut engine = Engine::new(); // Register the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); // Register an indexer. engine.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, X, U>(
&mut self,
callback: impl Fn(&mut T, X, U) -> Result<(), Box<EvalAltResult>> + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
where
T: Variant + Clone,
U: Variant + Clone,
X: Variant + Clone,
[src]
&mut self,
callback: impl Fn(&mut T, X, U) -> Result<(), Box<EvalAltResult>> + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
T: Variant + Clone,
U: Variant + Clone,
X: Variant + Clone,
Register an index setter for a custom type with the Engine
.
Returns Result<(), Box<EvalAltResult>>
.
Panics
Panics if the type is Array
or Map
.
Indexers for arrays, object maps and strings cannot be registered.
Example
use rhai::{Engine, Dynamic, EvalAltResult, RegisterFn}; #[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 the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); // Register an indexer. engine.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, X, U>(
&mut self,
getter: impl Fn(&mut T, X) -> U + SendSync + 'static,
setter: impl Fn(&mut T, X, U) + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
where
T: Variant + Clone,
U: Variant + Clone,
X: Variant + Clone,
[src]
&mut self,
getter: impl Fn(&mut T, X) -> U + SendSync + 'static,
setter: impl Fn(&mut T, X, U) + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
T: Variant + Clone,
U: Variant + Clone,
X: Variant + Clone,
Short-hand for register both index getter and setter functions for a custom type with the Engine
.
Panics
Panics if the type is Array
or Map
.
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, RegisterFn}; let mut engine = Engine::new(); // Register the custom type. engine.register_type::<TestStruct>(); engine.register_fn("new_ts", TestStruct::new); // Register an indexer. engine.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 compile(&self, script: &str) -> Result<AST, ParseError>
[src]
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>
[src]
&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_scripts_with_scope(
&self,
scope: &Scope<'_>,
scripts: &[&str]
) -> Result<AST, ParseError>
[src]
&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>>
[src]
Compile a script file into an AST
, which can be used later for evaluation.
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>>
[src]
&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.
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: &str,
has_null: bool
) -> Result<Map, Box<EvalAltResult>>
[src]
&self,
json: &str,
has_null: bool
) -> Result<Map, Box<EvalAltResult>>
Parse a JSON string into a map.
The JSON string must be an object hash. It cannot be a simple JavaScript primitive.
Set has_null
to true
in order to map null
values to ()
.
Setting it to false
will cause a variable not found 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,
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>
[src]
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>
[src]
&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>>
[src]
&self,
path: PathBuf
) -> Result<T, Box<EvalAltResult>>
Evaluate a script file.
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>>
[src]
&self,
scope: &mut Scope<'_>,
path: PathBuf
) -> Result<T, Box<EvalAltResult>>
Evaluate a script file with own scope.
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>>
[src]
&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>>
[src]
&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>>
[src]
&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>>
[src]
&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>>
[src]
&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>>
[src]
&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>>
[src]
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.
pub fn consume_file_with_scope(
&self,
scope: &mut Scope<'_>,
path: PathBuf
) -> Result<(), Box<EvalAltResult>>
[src]
&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.
pub fn consume(&self, script: &str) -> Result<(), Box<EvalAltResult>>
[src]
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>>
[src]
&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>>
[src]
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>>
[src]
&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<A: FuncArgs, T: Variant + Clone>(
&self,
scope: &mut Scope<'_>,
ast: &AST,
name: &str,
args: A
) -> Result<T, Box<EvalAltResult>>
[src]
&self,
scope: &mut Scope<'_>,
ast: &AST,
name: &str,
args: A
) -> Result<T, Box<EvalAltResult>>
Call a script function defined in an AST
with multiple arguments.
Arguments are passed as a tuple.
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", ( String::from("abc"), 123_i64 ) )?; assert_eq!(result, 168); let result: i64 = engine.call_fn(&mut scope, &ast, "add1", ( String::from("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<'_>,
lib: impl AsRef<Module>,
name: &str,
this_ptr: Option<&mut Dynamic>,
arg_values: impl AsMut<[Dynamic]>
) -> Result<Dynamic, Box<EvalAltResult>>
[src]
&self,
scope: &mut Scope<'_>,
lib: impl AsRef<Module>,
name: &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.
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, "add", None, [ String::from("abc").into(), 123_i64.into() ])?; // ^^^^ no 'this' pointer assert_eq!(result.cast::<i64>(), 168); let result = engine.call_fn_dynamic(&mut scope, &ast, "add1", None, [ String::from("abc").into() ])?; assert_eq!(result.cast::<i64>(), 46); let result = engine.call_fn_dynamic(&mut scope, &ast, "bar", None, [])?; assert_eq!(result.cast::<i64>(), 21); let mut value: Dynamic = 1_i64.into(); let result = engine.call_fn_dynamic(&mut scope, &ast, "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
[src]
&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 on_var(
&mut self,
callback: impl Fn(&str, usize, &EvalContext<'_, '_, '_, '_, '_, '_, '_, '_, '_>) -> Result<Option<Dynamic>, Box<EvalAltResult>> + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
&mut self,
callback: impl Fn(&str, usize, &EvalContext<'_, '_, '_, '_, '_, '_, '_, '_, '_>) -> Result<Option<Dynamic>, Box<EvalAltResult>> + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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ⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
&mut self,
callback: impl Fn(&u64) -> Option<Dynamic> + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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ⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
&mut self,
callback: impl Fn(&str) + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Override default action of print
(print to stdout using println!
)
Example
use rhai::Engine; let result = Arc::new(RwLock::new(String::from(""))); 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) + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
&mut self,
callback: impl Fn(&str) + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Override default action of debug
(print to stdout using println!
)
Example
use rhai::Engine; let result = Arc::new(RwLock::new(String::from(""))); let mut engine = Engine::new(); // Override action of 'print' function let logger = result.clone(); engine.on_debug(move |s| logger.write().unwrap().push_str(s)); engine.consume(r#"debug("hello");"#)?; assert_eq!(*result.read().unwrap(), r#""hello""#);
impl Engine
[src]
pub fn load_package(&mut self, package: impl Into<PackageLibrary>) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Load a new package into the Engine
.
Anything that can be converted into a PackageLibrary
is accepted, including a simple Module
.
When searching for functions, packages loaded later are preferred. In other words, loaded packages are searched in reverse order.
pub fn set_optimization_level(
&mut self,
optimization_level: OptimizationLevel
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
&mut self,
optimization_level: OptimizationLevel
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Control whether and how the Engine
will optimize an AST after compilation.
Not available under the no_optimize
feature.
pub fn optimization_level(&self) -> OptimizationLevel
[src]
The current optimization level.
It controls whether and how the Engine
will optimize an AST after compilation.
Not available under the no_optimize
feature.
pub fn set_max_call_levels(&mut self, levels: usize) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Set the maximum levels of function calls allowed for a script in order to avoid infinite recursion and stack overflows.
pub fn max_call_levels(&self) -> usize
[src]
The maximum levels of function calls allowed for a script.
pub fn set_max_operations(&mut self, operations: u64) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Set the maximum number of operations allowed for a script to run to avoid consuming too much resources (0 for unlimited).
pub fn max_operations(&self) -> u64
[src]
The maximum number of operations allowed for a script to run (0 for unlimited).
pub fn set_max_modules(&mut self, modules: usize) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Set the maximum number of imported modules allowed for a script.
pub fn max_modules(&self) -> usize
[src]
The maximum number of imported modules allowed for a script.
pub fn set_max_expr_depths(
&mut self,
max_expr_depth: usize,
max_function_expr_depth: usize
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
&mut self,
max_expr_depth: usize,
max_function_expr_depth: usize
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Set the depth limits for expressions (0 for unlimited).
pub fn max_expr_depth(&self) -> usize
[src]
The depth limit for expressions (0 for unlimited).
pub fn max_function_expr_depth(&self) -> usize
[src]
The depth limit for expressions in functions (0 for unlimited).
pub fn set_max_string_size(&mut self, max_size: usize) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Set the maximum length of strings (0 for unlimited).
pub fn max_string_size(&self) -> usize
[src]
The maximum length of strings (0 for unlimited).
pub fn set_max_array_size(&mut self, max_size: usize) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Set the maximum length of arrays (0 for unlimited).
pub fn max_array_size(&self) -> usize
[src]
The maximum length of arrays (0 for unlimited).
pub fn set_max_map_size(&mut self, max_size: usize) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Set the maximum length of object maps (0 for unlimited).
pub fn max_map_size(&self) -> usize
[src]
The maximum length of object maps (0 for unlimited).
pub fn set_module_resolver(
&mut self,
resolver: Option<impl ModuleResolver + 'static>
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
&mut self,
resolver: Option<impl ModuleResolver + 'static>
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Set the module resolution service used by the Engine
.
Not available under the no_module
feature.
pub fn disable_symbol(&mut self, symbol: &str) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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 variable name!
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 keyword
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: &str,
precedence: u8
) -> Result<&mut Self, String>
[src]
&mut self,
keyword: &str,
precedence: u8
) -> Result<&mut Self, String>
Register a custom operator into the language.
The operator must be a valid identifier (i.e. it cannot be a symbol).
Example
use rhai::{Engine, RegisterFn}; 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
[src]
pub fn register_custom_syntax<S: AsRef<str> + ToString>(
&mut self,
keywords: impl AsRef<[S]>,
new_vars: isize,
func: impl Fn(&mut EvalContext<'_, '_, '_, '_, '_, '_, '_, '_, '_>, &[Expression<'_>]) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static
) -> Result<&mut Self, ParseError>
[src]
&mut self,
keywords: impl AsRef<[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.
pub fn register_custom_syntax_raw(
&mut self,
key: impl Into<ImmutableString>,
parse: impl Fn(&[String]) -> Result<Option<String>, ParseError> + SendSync + 'static,
new_vars: isize,
func: impl Fn(&mut EvalContext<'_, '_, '_, '_, '_, '_, '_, '_, '_>, &[Expression<'_>]) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static
) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
&mut self,
key: impl Into<ImmutableString>,
parse: impl Fn(&[String]) -> Result<Option<String>, ParseError> + SendSync + 'static,
new_vars: isize,
func: impl Fn(&mut EvalContext<'_, '_, '_, '_, '_, '_, '_, '_, '_>, &[Expression<'_>]) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static
) -> &mut Selfⓘ
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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
[src]
pub fn lex<'a, 'e>(
&'e self,
input: impl IntoIterator<Item = &'a &'a str>,
map: Option<Box<dyn Fn(Token) -> Token>>
) -> TokenIterator<'a, 'e>
[src]
&'e self,
input: impl IntoIterator<Item = &'a &'a str>,
map: Option<Box<dyn Fn(Token) -> Token>>
) -> TokenIterator<'a, 'e>
Tokenize an input text stream.
Trait Implementations
impl Debug for Engine
[src]
impl Default for Engine
[src]
impl<RET: Variant + Clone> Func<(), RET> for Engine
[src]
type Output = Box<dyn Fn() -> Result<RET, Box<EvalAltResult>>>
fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
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
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
impl<S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(S, T, U, V), RET> for Engine
[src]
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
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
impl<T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(T, U, V), RET> for Engine
[src]
type Output = Box<dyn Fn(T, U, V) -> Result<RET, Box<EvalAltResult>>>
fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
impl<U: Variant + Clone, V: Variant + Clone, RET: Variant + Clone> Func<(U, V), RET> for Engine
[src]
type Output = Box<dyn Fn(U, V) -> Result<RET, Box<EvalAltResult>>>
fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
impl<V: Variant + Clone, RET: Variant + Clone> Func<(V,), RET> for Engine
[src]
type Output = Box<dyn Fn(V) -> Result<RET, Box<EvalAltResult>>>
fn create_from_ast(self, ast: AST, entry_point: &str) -> Self::Output
[src]
fn create_from_script(
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
[src]
self,
script: &str,
entry_point: &str
) -> Result<Self::Output, ParseError>
impl<FN: Fn() -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<A>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<B>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<C>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<D>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<E>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<F>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<G>, H, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut H, J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<H>, J, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut J, K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<J>, K, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut K, L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<K>, L, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut L, M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<L>, M, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut M, N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<M>, N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<N>, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<P>, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<Q>, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<R>, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<S>, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<T>, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<U>, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<V: Variant + Clone, FN: Fn(&mut V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Mut<V>,), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(N, P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (N, P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(P, Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (P, Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(Q, R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (Q, R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(R, S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (R, S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(S, T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (S, T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(T, U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (T, U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<U: Variant + Clone, V: Variant + Clone, FN: Fn(U, V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (U, V), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<V: Variant + Clone, FN: Fn(V) -> RET + SendSync + 'static, RET: Variant + Clone> RegisterFn<FN, (V,), RET> for Engine
[src]
fn register_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<FN: Fn() -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, ()> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut A, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<A>, B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut B, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<B>, C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut C, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<C>, D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut D, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<D>, E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut E, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<E>, F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut F, G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<F>, G, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut G, H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<G>, H, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut H, J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<H>, J, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut J, K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<J>, K, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut K, L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<K>, L, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut L, M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<L>, M, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut M, N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<M>, N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(&mut N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<N>, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<P>, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<Q>, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<R>, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<S>, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<T>, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<U: Variant + Clone, V: Variant + Clone, FN: Fn(&mut U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<U>, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<V: Variant + Clone, FN: Fn(&mut V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Mut<V>,)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
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, FN: Fn(N, P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (N, P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<P: Variant + Clone, Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(P, Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (P, Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<Q: Variant + Clone, R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(Q, R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (Q, R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<R: Variant + Clone, S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(R, S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (R, S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<S: Variant + Clone, T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(S, T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (S, T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<T: Variant + Clone, U: Variant + Clone, V: Variant + Clone, FN: Fn(T, U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (T, U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<U: Variant + Clone, V: Variant + Clone, FN: Fn(U, V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (U, V)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<V: Variant + Clone, FN: Fn(V) -> Result<Dynamic, Box<EvalAltResult>> + SendSync + 'static> RegisterResultFn<FN, (V,)> for Engine
[src]
fn register_result_fn(&mut self, name: &str, f: FN) -> &mut SelfⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
Auto Trait Implementations
impl !RefUnwindSafe for Engine
impl !Send for Engine
impl !Sync for Engine
impl Unpin for Engine
impl !UnwindSafe for Engine
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow(&self) -> &TⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
[src]
Notable traits for &'_ mut W
impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,