Code refactor, bug fixes, code docs.

src/fn_register.rs

@@ -1,13 +1,59 @@
 use std::any::TypeId;
 
 use crate::any::{Any, Dynamic};
-use crate::engine::{Engine, EvalAltResult, FnCallArgs};
+use crate::engine::{Engine, FnCallArgs};
 use crate::parser::Position;
+use crate::result::EvalAltResult;
 
+/// A trait to register custom functions with the `Engine`.
+///
+/// # Example
+///
+/// ```rust
+/// use rhai::{Engine, RegisterFn};
+///
+/// // Normal function
+/// fn add(x: i64, y: i64) -> i64 {
+///     x + y
+/// }
+///
+/// let mut engine = Engine::new();
+///
+/// // You must use the trait rhai::RegisterFn to get this method.
+/// engine.register_fn("add", add);
+///
+/// if let Ok(result) = engine.eval::<i64>("add(40, 2)") {
+///    println!("Answer: {}", result);  // prints 42
+/// }
+/// ```
 pub trait RegisterFn<FN, ARGS, RET> {
+    /// Register a custom function with the `Engine`.
     fn register_fn(&mut self, name: &str, f: FN);
 }
+
+/// A trait to register custom functions that return `Dynamic` values with the `Engine`.
+///
+/// # Example
+///
+/// ```rust
+/// use rhai::{Engine, RegisterDynamicFn, Dynamic};
+///
+/// // Function that returns a Dynamic value
+/// fn get_an_any(x: i64) -> Dynamic {
+///     Box::new(x)
+/// }
+///
+/// let mut engine = Engine::new();
+///
+/// // You must use the trait rhai::RegisterDynamicFn to get this method.
+/// engine.register_dynamic_fn("get_an_any", get_an_any);
+///
+/// if let Ok(result) = engine.eval::<i64>("get_an_any(42)") {
+///    println!("Answer: {}", result);  // prints 42
+/// }
+/// ```
 pub trait RegisterDynamicFn<FN, ARGS> {
+    /// Register a custom function returning `Dynamic` values with the `Engine`.
     fn register_dynamic_fn(&mut self, name: &str, f: FN);
 }
 
@@ -28,7 +74,7 @@ macro_rules! def_register {
             $($par: Any + Clone,)*
             FN: Fn($($param),*) -> RET + 'static,
             RET: Any
-        > RegisterFn<FN, ($($mark,)*), RET> for Engine
+        > RegisterFn<FN, ($($mark,)*), RET> for Engine<'_>
         {
             fn register_fn(&mut self, name: &str, f: FN) {
                 let fn_name = name.to_string();
@@ -54,14 +100,14 @@ macro_rules! def_register {
                         Ok(Box::new(r) as Dynamic)
                     }
                 };
-                self.register_fn_raw(name.into(), Some(vec![$(TypeId::of::<$par>()),*]), Box::new(fun));
+                self.register_fn_raw(name, Some(vec![$(TypeId::of::<$par>()),*]), Box::new(fun));
             }
         }
 
         impl<
             $($par: Any + Clone,)*
             FN: Fn($($param),*) -> Dynamic + 'static,
-        > RegisterDynamicFn<FN, ($($mark,)*)> for Engine
+        > RegisterDynamicFn<FN, ($($mark,)*)> for Engine<'_>
         {
             fn register_dynamic_fn(&mut self, name: &str, f: FN) {
                 let fn_name = name.to_string();
@@ -86,7 +132,7 @@ macro_rules! def_register {
                         Ok(f($(($clone)($par)),*))
                     }
                 };
-                self.register_fn_raw(name.into(), Some(vec![$(TypeId::of::<$par>()),*]), Box::new(fun));
+                self.register_fn_raw(name, Some(vec![$(TypeId::of::<$par>()),*]), Box::new(fun));
             }
         }