Refine docs and API.

src/api.rs

@@ -1325,8 +1325,7 @@ impl Engine {
         args: A,
     ) -> Result<T, Box<EvalAltResult>> {
         let mut arg_values = args.into_vec();
-        let result =
-            self.call_fn_dynamic_raw(scope, ast.lib(), name, &mut None, arg_values.as_mut())?;
+        let result = self.call_fn_dynamic_raw(scope, ast, name, &mut None, arg_values.as_mut())?;
 
         let typ = self.map_type_name(result.type_name());
 
@@ -1370,19 +1369,19 @@ impl Engine {
     /// scope.push("foo", 42_i64);
     ///
     /// // Call the script-defined function
-    /// let result = engine.call_fn_dynamic(&mut scope, ast.into(), "add", None, [ String::from("abc").into(), 123_i64.into() ])?;
-    /// //                                                                 ^^^^ no 'this' pointer
+    /// 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.into(), "add1", None, [ String::from("abc").into() ])?;
+    /// 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.into(), "bar", None, [])?;
+    /// 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.into(), "action", Some(&mut value), [ 41_i64.into() ])?;
-    /// //                                                                    ^^^^^^^^^^^^^^^^ binding the 'this' pointer
+    /// 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);
     /// # }
     /// # Ok(())
@@ -1392,7 +1391,7 @@ impl Engine {
     pub fn call_fn_dynamic(
         &self,
         scope: &mut Scope,
-        lib: &Module,
+        lib: impl AsRef<Module>,
         name: &str,
         mut this_ptr: Option<&mut Dynamic>,
         mut arg_values: impl AsMut<[Dynamic]>,
@@ -1412,11 +1411,12 @@ impl Engine {
     pub(crate) fn call_fn_dynamic_raw(
         &self,
         scope: &mut Scope,
-        lib: &Module,
+        lib: impl AsRef<Module>,
         name: &str,
         this_ptr: &mut Option<&mut Dynamic>,
         arg_values: &mut [Dynamic],
     ) -> Result<Dynamic, Box<EvalAltResult>> {
+        let lib = lib.as_ref();
         let mut args: StaticVec<_> = arg_values.iter_mut().collect();
         let fn_def =
             get_script_function_by_signature(lib, name, args.len(), true).ok_or_else(|| {

src/fn_func.rs

@@ -15,8 +15,8 @@ use crate::stdlib::{boxed::Box, string::ToString};
 pub trait Func<ARGS, RET> {
     type Output;
 
-    /// Create a Rust anonymous function from an [`AST`].
-    /// The `Engine` and [`AST`] are consumed and basically embedded into the closure.
+    /// Create a Rust anonymous function from an `AST`.
+    /// The `Engine` and `AST` are consumed and basically embedded into the closure.
     ///
     /// # Examples
     ///

src/lib.rs

@@ -62,7 +62,7 @@
 //! | `only_i32`    | Set the system integer type to `i32` and disable all other integer types. `INT` is set to `i32`.                                  |
 //! | `only_i64`    | Set the system integer type to `i64` and disable all other integer types. `INT` is set to `i64`.                                  |
 //! | `no_std`      | Build for `no-std`. Notice that additional dependencies will be pulled in to replace `std` features.                              |
-//! | `sync`        | Restrict all values types to those that are `Send + Sync`. Under this feature, `Engine`, `Scope` and [`AST`] are all `Send + Sync`. |
+//! | `sync`        | Restrict all values types to those that are `Send + Sync`. Under this feature, `Engine`, `Scope` and `AST` are all `Send + Sync`. |
 //! | `serde`       | Enable serialization/deserialization via `serde`. Notice that the [`serde`](https://crates.io/crates/serde) crate will be pulled in together with its dependencies. |
 //! | `internals`   | Expose internal data structures (beware they may be volatile from version to version).                                            |
 //!

src/module.rs

@@ -102,6 +102,12 @@ impl Clone for Module {
     }
 }
 
+impl AsRef<Module> for Module {
+    fn as_ref(&self) -> &Module {
+        self
+    }
+}
+
 impl Module {
     /// Create a new module.
     ///

src/parser.rs

@@ -66,14 +66,14 @@ impl AST {
 
     /// Get the statements.
     #[cfg(not(feature = "internals"))]
-    pub(crate) fn statements(&self) -> &Vec<Stmt> {
+    pub(crate) fn statements(&self) -> &[Stmt] {
         &self.0
     }
 
     /// Get the statements.
     #[cfg(feature = "internals")]
     #[deprecated(note = "this method is volatile and may change")]
-    pub fn statements(&self) -> &Vec<Stmt> {
+    pub fn statements(&self) -> &[Stmt] {
         &self.0
     }
 
@@ -298,9 +298,15 @@ impl Add<Self> for &AST {
     }
 }
 
-impl<'a> From<&'a AST> for &'a Module {
-    fn from(ast: &'a AST) -> Self {
-        ast.lib()
+impl AsRef<[Stmt]> for AST {
+    fn as_ref(&self) -> &[Stmt] {
+        self.statements()
+    }
+}
+
+impl AsRef<Module> for AST {
+    fn as_ref(&self) -> &Module {
+        self.lib()
     }
 }
 

src/settings.rs

@@ -218,8 +218,8 @@ impl Engine {
     /// let mut engine = Engine::new();
     ///
     /// // Register a custom operator called 'foo' and give it
-    /// // a precedence of 140 (i.e. between +|- and *|/).
-    /// engine.register_custom_operator("foo", 140).unwrap();
+    /// // 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));