Refactor.

src/api.rs

@@ -422,7 +422,7 @@ impl Engine {
         self.register_indexer_set(setter);
     }
 
-    /// Compile a string into an `AST`, which can be used later for evaluation.
+    /// Compile a string into an [`AST`], which can be used later for evaluation.
     ///
     /// # Example
     ///
@@ -445,7 +445,7 @@ impl Engine {
         self.compile_with_scope(&Scope::new(), script)
     }
 
-    /// Compile a string into an `AST` using own scope, which can be used later for evaluation.
+    /// 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`.
@@ -488,7 +488,7 @@ impl Engine {
     }
 
     /// 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.
+    /// 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`.
@@ -541,7 +541,7 @@ impl Engine {
         self.compile_with_scope_and_optimization_level(scope, scripts, self.optimization_level)
     }
 
-    /// Join a list of strings and compile into an `AST` using own scope at a specific optimization level.
+    /// Join a list of strings and compile into an [`AST`] using own scope at a specific optimization level.
     pub(crate) fn compile_with_scope_and_optimization_level(
         &self,
         scope: &Scope,
@@ -577,7 +577,7 @@ impl Engine {
         Ok(contents)
     }
 
-    /// Compile a script file into an `AST`, which can be used later for evaluation.
+    /// Compile a script file into an [`AST`], which can be used later for evaluation.
     ///
     /// # Example
     ///
@@ -603,7 +603,7 @@ impl Engine {
         self.compile_file_with_scope(&Scope::new(), path)
     }
 
-    /// Compile a script file into an `AST` using own scope, which can be used later for evaluation.
+    /// 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`.
@@ -685,7 +685,7 @@ impl Engine {
         self.eval_ast_with_scope(&mut scope, &ast)
     }
 
-    /// Compile a string containing an expression into an `AST`,
+    /// Compile a string containing an expression into an [`AST`],
     /// which can be used later for evaluation.
     ///
     /// # Example
@@ -709,7 +709,7 @@ impl Engine {
         self.compile_expression_with_scope(&Scope::new(), script)
     }
 
-    /// Compile a string containing an expression into an `AST` using own scope,
+    /// 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
@@ -917,7 +917,7 @@ impl Engine {
         self.eval_ast_with_scope(scope, &ast)
     }
 
-    /// Evaluate an `AST`.
+    /// Evaluate an [`AST`].
     ///
     /// # Example
     ///
@@ -939,7 +939,7 @@ impl Engine {
         self.eval_ast_with_scope(&mut Scope::new(), ast)
     }
 
-    /// Evaluate an `AST` with own scope.
+    /// Evaluate an [`AST`] with own scope.
     ///
     /// # Example
     ///
@@ -986,7 +986,7 @@ impl Engine {
         });
     }
 
-    /// Evaluate an `AST` with own scope.
+    /// Evaluate an [`AST`] with own scope.
     pub(crate) fn eval_ast_with_scope_raw<'a>(
         &self,
         scope: &mut Scope,
@@ -1052,7 +1052,7 @@ impl Engine {
         self.consume_ast_with_scope(&mut Scope::new(), ast)
     }
 
-    /// Evaluate an `AST` with own scope, but throw away the result and only return error (if any).
+    /// 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 consume_ast_with_scope(
         &self,
@@ -1076,7 +1076,7 @@ impl Engine {
             )
     }
 
-    /// Call a script function defined in an `AST` with multiple arguments.
+    /// Call a script function defined in an [`AST`] with multiple arguments.
     /// Arguments are passed as a tuple.
     ///
     /// # Example
@@ -1133,7 +1133,7 @@ impl Engine {
         });
     }
 
-    /// Call a script function defined in an `AST` with multiple `Dynamic` arguments.
+    /// Call a script function defined in an [`AST`] with multiple `Dynamic` arguments.
     ///
     /// # Example
     ///
@@ -1179,7 +1179,7 @@ impl Engine {
         self.call_fn_dynamic_raw(scope, ast, name, arg_values.as_mut())
     }
 
-    /// Call a script function defined in an `AST` with multiple `Dynamic` arguments.
+    /// Call a script function defined in an [`AST`] with multiple `Dynamic` arguments.
     ///
     /// ## WARNING
     ///
@@ -1220,15 +1220,15 @@ impl Engine {
         )
     }
 
-    /// Optimize the `AST` with constants defined in an external Scope.
-    /// An optimized copy of the `AST` is returned while the original `AST` is consumed.
+    /// 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
+    /// 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
+    /// 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.
     #[cfg(not(feature = "no_optimize"))]