Revise package terminology.

doc/src/rust/modules/create.md

@@ -19,8 +19,8 @@ Manually creating a [module] is possible via the `Module` API.
 For the complete `Module` API, refer to the [documentation](https://docs.rs/rhai/{{version}}/rhai/struct.Module.html) online.
 
 
-Make the `Module` Globally Available
------------------------------------
+Use Case 1 - Make the `Module` Globally Available
+------------------------------------------------
 
 `Engine::register_global_module` registers a shared [module] into the _global_ namespace.
 
@@ -44,14 +44,14 @@ module.update_fn_metadata(hash, ["x: i64", "i64"]);
 
 // Register the module into the global namespace of the Engine.
 let mut engine = Engine::new();
-engine.register_global_module(module);
+engine.register_global_module(module.into());
 
 engine.eval::<i64>("inc(41)")? == 42;       // no need to import module
 ```
 
 
-Make the `Module` a Static Module
---------------------------------
+Use Case 2 - Make the `Module` a Static Module
+---------------------------------------------
 
 `Engine::register_static_module` registers a [module] and under a specific module namespace.
 
@@ -69,15 +69,18 @@ module.update_fn_metadata(hash, ["x: i64", "i64"]);
 
 // Register the module into the Engine as a static module namespace 'calc'
 let mut engine = Engine::new();
-engine.register_static_module("calc", module);
+engine.register_static_module("calc", module.into());
 
 engine.eval::<i64>("calc::inc(41)")? == 42; // refer to the 'Calc' module
 ```
 
-`Module::set_fn_XXX_mut` can expose functions (usually _methods_) in the module
-to the _global_ namespace, so [getters/setters] and [indexers] for [custom types] can work as expected.
+### Expose Functions to the Global Namespace
 
-[Type iterators], because of their special nature, are always exposed to the _global_ namespace.
+`Module::set_fn_mut` and `Module::set_fn_XXX_mut` can optionally expose functions (usually _methods_)
+in the module to the _global_ namespace, so [getters/setters] and [indexers] for [custom types]
+can work as expected.
+
+[Type iterators], because of their special nature, are _always_ exposed to the _global_ namespace.
 
 ```rust
 use rhai::{Engine, Module, FnNamespace};
@@ -93,15 +96,15 @@ module.update_fn_metadata(hash, ["x: &mut i64", "i64"]);
 
 // Register the module into the Engine as a static module namespace 'calc'
 let mut engine = Engine::new();
-engine.register_static_module("calc", module);
+engine.register_static_module("calc", module.into());
 
 // The method 'inc' works as expected because it is exposed to the global namespace
 engine.eval::<i64>("let x = 41; x.inc()")? == 42;
 ```
 
 
-Make the `Module` Dynamically Loadable
--------------------------------------
+Use Case 3 - Make the `Module` Dynamically Loadable
+--------------------------------------------------
 
 In order to dynamically load a custom module, there must be a [module resolver] which serves
 the module when loaded via `import` statements.

doc/src/rust/modules/index.md

@@ -3,12 +3,27 @@ Modules
 
 {{#include ../../links.md}}
 
-Rhai allows organizing code (functions, both Rust-based or script-based, and variables) into _modules_.
-Modules can be disabled via the [`no_module`] feature.
+Rhai allows organizing functionalities (functions, both Rust-based or script-based, and variables)
+into independent _modules_. Modules can be disabled via the [`no_module`] feature.
 
-A module is of the type `Module` and holds a collection of functions, variables, [type iterators] and sub-modules.
-It may be created entirely from Rust functions, or it may encapsulate a Rhai script together with the functions
-and variables defined by that script.
+A module is of the type `Module` and holds a collection of functions, variables,
+[type iterators] and sub-modules.
+
+It may be created entirely from Rust functions, or it may encapsulate a Rhai script together
+with the functions and variables defined by that script.
 
 Other scripts can then load this module and use the functions and variables exported
 as if they were defined inside the same script.
+
+Alternatively, modules can be registered directly into an [`Engine`] and made available
+to scripts either globally or under individual static module [_namespaces_][function namespaces].
+
+
+Usage Patterns
+--------------
+
+| Usage          |                API                |          Lookup          | Sub-modules? | Variables? |
+| -------------- | :-------------------------------: | :----------------------: | :----------: | :--------: |
+| Global module  | `Engine:: register_global_module` |       simple name        |   ignored    |  ignored   |
+| Static module  | `Engine:: register_static_module` | namespace-qualified name |     yes      |    yes     |
+| Dynamic module |       [`import`] statement        | namespace-qualified name |     yes      |    yes     |