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 statement block ends,
                        //                  therefore it is not 'global' and cannot be exported

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

Tip: Multiple exports

[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
export x;
export x as hello;
export y as foo;
export x as world;
export y as bar;
export z;

Do not export closures

A function pointer, anonymous function or closure, is not a first-class function.

It is syntactic sugar only, capturing the name of a function to call.

Exporting them causes a runtime error.

Export Functions

Private functions

private functions are commonly called within the module 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.

Tip: Skip exporting a module

To prevent a module from being exported, load it inside a block statement so that it goes away at the end of the block.

// This is a module script.

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

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