exportFunction (inputsSchema output options callable name --)

Inputs

• inputsSchema: Descriptor of the exported function input stack.
• output: Descriptor of the exported function output stack.
• options: Descriptor of the exported function calling options.
• callable: Block compiled as the exported body.
• name: Known exported function name.

Outputs

• None.

exportFunction constructs a function signature, compiles the supplied Block, records the resulting function declaration, and creates the exported function name in the current module.

The stack contract follows the declared signature. When the exported function starts at runtime, its declared inputs are on the data stack. Named access inside the body still requires explicit binding. Names written inside inputsSchema therefore belong only to the signature, not to the surrounding scope.

Behavior

• inputsSchema, output, and options are interpreted through the same signature-building logic as codeRef. In that logic, inputsSchema and options are Dict descriptors or the empty Tuple (). The recognized option fields are convention (Text) and variadic (Cond); see Options descriptor on the codeRef page for the full specification.
• name must be known, non-NIL, non-empty Text.
• When the block starts, its declared inputs are on the data stack in reverse declaration order: the first input is the top item and the last input is the deepest. This matches the C parameter order seen by external callers, and it is the same layout that importFunction uses at call sites.
• The compiled block must consume every declared input and finish with exactly the declared output on its data stack.
• Valid only at module level.
• If the function name was already declared with a different signature, compilation fails.
• If the function name was already defined, compilation fails.
• The function body is compiled immediately, so compile-time effects inside the block happen while the module is compiled.
• The created exported Code name is immediately usable in the current module.
• The created exported name is usable and non-NIL, but known? still reports FALSE for it.
• Pending overload and private modifiers apply to the exported name. A pending virtual modifier is invalid here.

Example

exportExample.mpl

{} 0 {} [
  "-- zero-input body compiled --" printCompilerMessage
  7
] "seven" exportFunction

{ value: 0; } 0 {} [
  value:;
  "-- one-input body compiled --" printCompilerMessage
  value 1 +
] "addOne" exportFunction

"-- exported name immediately usable here --" printCompilerMessage
@addOne printStack _:;
@addOne known? printStack _:;

test.mpl

"String"               use
"exportExample.addOne" use
"exportExample.seven"  use

{} 0 {} [
  ("-- zero-input function -- " seven "\n") printList
  ("-- one-input function -- " 5 addOne "\n") printList
  @addOne known? printStack _:;
  0
] "main" exportFunction

Expected Output During Compilation

-- zero-input body compiled --
-- one-input body compiled --
-- exported name immediately usable here --
{value: Int32;} Int32 {} codeRef
FALSE
FALSE

Expected Output

-- zero-input function -- 7
-- one-input function -- 6

See also

• NAME: ...; node — Pushes a name onto the name stack and creates a local by consuming that name and one data-stack object.
• codeRef builtin (inputsSchema output options -- code) Constructs a Code schema and pushes a known NIL Code object of that schema.
• def builtin (object name --) Creates a named local or field using a known Text name.
• importFunction builtin (inputsSchema output options name --) Declares or imports a named function with the supplied signature and binds it in the current scope as a Code local.
• importVariable builtin (schema name --) Creates a local that refers to an external variable of the requested non-Meta schema; the created local is treated as unknown.
• use builtin (moduleDescriptor --) Imports public names from a module path named by known Text, or imports one selected public name when the last dot after the last path separator separates the module path from that name.