Export Variables, Functions and Sub-Modules From a Script

The easiest way to expose a collection of functions as a self-contained module is to do it via a Rhai script itself.

The script text is evaluated.

Variables are then selectively exposed via the export statement.

Functions defined by the script are automatically exported, unless marked as private.

Modules loaded within this module at the global level become sub-modules and are also automatically exported.

Export Global Constants

The export statement, which can only be at global level, exposes a selected variable as member of a module.

Variables not exported are private and hidden. They are merely used to initialize the module, but cannot be accessed from outside.

Everything exported from a module is constant (i.e. read-only).

// This is a module script.

let hidden = 123;       // variable not exported - default hidden
let x = 42;             // this will be exported below

export x;               // the variable 'x' is exported under its own name

export const x = 42;    // convenient short-hand to declare a constant and export it
                        // under its own name

export let x = 123;     // variables can be exported as well, though it'll still be constant

export x as answer;     // the variable 'x' is exported under the alias 'answer'
                        // another script can load this module and access 'x' as 'module::answer'

{
    let inner = 0;      // local variable - it disappears when the statements block ends,
                        //                  therefore it is not 'global' and cannot be exported

    export inner;       // <- syntax error: cannot export a local variable
}

[Variables] can be exported under multiple names.
For example, the following exports three [variables]:
* `x` as `x` and `hello`
* `y` as `foo` and `bar`
* `z` as `z`

~~~js
export x;
export x as hello;
export y as foo;
export x as world;
export y as bar;
export z;
~~~

A [function pointer](../fn-ptr.md), [anonymous function](../fn-anon.md) or [closure](../fn-closure.md),
is not a _first-class function_.

It is _syntactic sugar_ only, capturing the _name_ of a [function](../functions.md) to call.

Exporting them causes a runtime error.

Export Functions

`private` [functions](../functions.md) are commonly called within the [module](index.md) only.
They cannot be accessed otherwise.

All functions are automatically exported, unless it is explicitly opt-out with the private prefix.

Functions declared private are hidden to the outside.

// This is a module script.

fn inc(x) { x + 1 }     // script-defined function - default public

private fn foo() {}     // private function - hidden

Sub-Modules

All loaded modules are automatically exported as sub-modules.

To prevent a [module](index.md) from being exported, load it inside a block statement
so that it goes away at the end of the block.

```js
// This is a module script.

import "hello" as foo;      // <- exported

{
    import "world" as bar;  // <- not exported
}
```