1) Change namespaces to iter_namespaces

2) throw can throw any value

doc/src/language/fn-ptr.md

@@ -199,9 +199,9 @@ fn call_fn_ptr_with_value(context: NativeCallContext, args: &mut [&mut Dynamic])
     -> Result<Dynamic, Box<EvalAltResult>>
 {
     // 'args' is guaranteed to contain enough arguments of the correct types
-    let fp = std::mem::take(args[1]).cast::<FnPtr>();       // 2nd argument - function pointer
-    let value = args[2].clone();                            // 3rd argument - function argument
-    let this_ptr = args.get_mut(0).unwrap();                // 1st argument - this pointer
+    let fp = std::mem::take(args[1]).cast::<FnPtr>();   // 2nd argument - function pointer
+    let value = args[2].clone();                        // 3rd argument - function argument
+    let this_ptr = args.get_mut(0).unwrap();            // 1st argument - this pointer
 
     // Use 'FnPtr::call_dynamic' to call the function pointer.
     // Beware, private script-defined functions will not be found.
@@ -238,7 +238,7 @@ let engine = Engine::new();
 let mut ast = engine.compile(
     r#"
         let test = "hello";
-        |x| test + x                // this creates an closure
+        |x| test + x            // this creates an closure
     "#,
 )?;
 
@@ -248,9 +248,13 @@ let fn_ptr = engine.eval_ast::<FnPtr>(&ast)?;
 // Get rid of the script, retaining only functions
 ast.retain_functions(|_, _, _| true);
 
-// Create native call context via a tuple containing the Engine and the
-// set of script-defined functions (within the AST) in form of a slice.
-let context = (&engine, &[ast.as_ref()]).into();
+// Create native call context via a tuple
+let context =
+        (
+            &engine,            // the 'Engine'
+            &[ast.as_ref()]     // function namespace from the 'AST'
+                                // as a one-element slice
+        ).into();
 
 // 'f' captures: the engine, the AST, and the closure
 let f = move |x: i64| fn_ptr.call_dynamic(context, None, [x.into()]);

doc/src/language/throw.md

@@ -10,24 +10,24 @@ To deliberately return an error during an evaluation, use the `throw` keyword.
 
 ```rust
 if some_bad_condition_has_happened {
-    throw error;    // 'throw' takes a string as the exception text
+    throw error;    // 'throw' any value as the exception
 }
 
-throw;              // defaults to empty exception text: ""
+throw;              // defaults to '()'
 ```
 
 Exceptions thrown via `throw` in the script can be captured in Rust by matching
-`Err(Box<EvalAltResult::ErrorRuntime(reason, position)>)` with the exception text
-captured by `reason`.
+`Err(Box<EvalAltResult::ErrorRuntime(value, position)>)` with the exception value
+captured by `value`.
 
 ```rust
 let result = engine.eval::<i64>(r#"
     let x = 42;
 
     if x > 0 {
-        throw x + " is too large!";
+        throw x;
     }
 "#);
 
-println!(result);   // prints "Runtime error: 42 is too large! (line 5, position 15)"
+println!(result);   // prints "Runtime error: 42 (line 5, position 15)"
 ```