reorganize module

_archive/rhai_engine/rhaibook/engine/strict-var.md

@@ -0,0 +1,75 @@
+Strict Variables Mode
+=====================
+
+{{#include ../links.md}}
+
+~~~admonish tip.side "`Scope` constants"
+
+[Constants] in the external [`Scope`], when provided, count as definition.
+~~~
+
+By default, Rhai looks up access to [variables] from the enclosing block scope,
+working its way outwards until it reaches the top (global) level, then it
+searches the [`Scope`] (if any) that is passed into the `Engine::eval_with_scope` call.
+
+Setting [`Engine::set_strict_variables`][options] to `true` turns on _Strict Variables Mode_,
+which requires that:
+
+* all [variables]/[constants] be defined within the same script before use,
+  or they must be [variables]/[constants] within the provided [`Scope`] (if any),
+* [modules] must be [imported][`import`], also within the same script, before use.
+
+Within _Strict Variables_ mode, any attempt to access a [variable] or [module] before
+definition/[import][`import`] results in a parse error.
+
+This way, variable access errors (usually typos) are caught during compile time instead of runtime.
+
+```rust
+let x = 42;
+
+let y = x * z;          // <- parse error under strict variables mode:
+                        //    variable 'z' is not yet defined
+
+let z = x + w;          // <- parse error under strict variables mode:
+                        //    variable 'w' is undefined
+
+foo::bar::baz();        // <- parse error under strict variables mode:
+                        //    module 'foo' is not yet defined
+
+fn test1() {
+    foo::bar::baz();    // <- parse error under strict variables mode:
+                        //    module 'foo' is defined
+}
+
+import "my_module" as foo;
+
+foo::bar::baz();        // ok!
+
+print(foo::xyz);        // ok!
+
+let x = abc::def;       // <- parse error under strict variables mode:
+                        //    module 'abc' is undefined
+
+fn test2() {
+    foo:bar::baz();     // ok!
+}
+```
+
+
+```admonish question "TL;DR &ndash; Why isn't there a _Strict Functions_ mode?"
+
+Why can't function calls be checked for validity as well?
+
+Rust functions in Rhai can be [overloaded][function overloading]. This means that multiple versions of
+the same Rust function can exist under the same name, each accepting different numbers and/or types
+of arguments.
+
+While it is possible to check, at compile time, whether a [variable] has been previously declared,
+it is impossible to predict, at compile time, the _types_ of arguments to function calls, unless the
+function in question takes no parameters.
+
+Therefore, it is impossible to check, at compile time, whether a function call is valid given that
+the types of arguments are unknown until runtime. QED.
+
+Not to mention that it is also impossible to check for a function called via a [function pointer].
+```