Edit documentation.

doc/src/language/modules/imp-resolver.md

@@ -7,8 +7,8 @@ For many applications in which Rhai is embedded, it is necessary to customize th
 are resolved.  For instance, modules may need to be loaded from script texts stored in a database,
 not in the file system.
 
-A module resolver must implement the trait `rhai::ModuleResolver`, which contains only one function:
-`resolve`.
+A module resolver must implement the trait [`rhai::ModuleResolver`]({{rootUrl}}/rust/traits.md),
+which contains only one function: `resolve`.
 
 When Rhai prepares to load a module, `ModuleResolver::resolve` is called with the name
 of the _module path_ (i.e. the path specified in the [`import`] statement). Upon success, it should

doc/src/language/modules/import.md

@@ -3,6 +3,9 @@ Import a Module
 
 {{#include ../../links.md}}
 
+`import` Statement
+-----------------
+
 A module can be _imported_ via the `import` statement, and its members are accessed via '`::`' similar to C++.
 
 ```rust
@@ -17,10 +20,14 @@ print(lock::status);            // module variables are constants
 lock::status = "off";           // <- runtime error - cannot modify a constant
 ```
 
+
+Scoped Imports
+--------------
+
 `import` statements are _scoped_, meaning that they are only accessible inside the scope that they're imported.
 
 They can appear anywhere a normal statement can be, but in the vast majority of cases `import` statements are
-group at the beginning of a script. It is, however, not advised to deviate from this common practice unless
+group at the beginning of a script. It is not advised to deviate from this common practice unless
 there is a _Very Good Reason™_.
 
 Especially, do not place an `import` statement within a loop; doing so will repeatedly re-load the same module
@@ -44,3 +51,32 @@ for x in range(0, 1000) {
     c.encrypt(something);
 }
 ```
+
+
+Recursive Imports
+----------------
+
+Beware of _import cycles_ - i.e. recursively loading the same module. This is a sure-fire way to
+cause a stack overflow in the [`Engine`], unless stopped by setting a limit for [maximum number of modules].
+
+For instance, importing itself always causes an infinite recursion:
+
+```rust
+// This file is 'hello.rhai'
+
+import "hello" as foo;          // import itself - infinite recursion!
+
+foo::do_something();
+```
+
+Modules cross-referencing also cause infinite recursion:
+
+```rust
+// This file is 'hello.rhai' - references 'world.rhai'
+import "world" as foo;
+foo::do_something();
+
+// This file is 'world.rhai' - references 'hello.rhai'
+import "hello" as bar;
+bar::do_something_else();
+```

doc/src/language/modules/index.md

@@ -0,0 +1,18 @@
+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.
+
+A module is of the type `Module` and encapsulates a Rhai script together with the functions defined
+by that script.
+
+The script text is run, variables are then selectively exposed via the [`export`] statement.
+Functions defined by the script are automatically exported.
+
+Modules loaded within this module at the global level become _sub-modules_ and are also automatically exported.
+
+Other scripts can then load this module and use the variables and functions exported
+as if they were defined inside the same script.