overload (--)

Inputs

• None.

Outputs

• None.

overload creates a pending overload specifier in the current scope.

That pending specifier is consumed by the next successful local creation. Intervening operations do not consume it.

Known issue: when that local is a field created inside { ... } while another name exists in its module or in an already loaded module, such as an imported name, an earlier local or field, or a -D definition, mplc can abort: it prints an internal assertion, such as NameItem.key is inconsistent, and stops without Compilation failed. Mentioning the field's name after the Dict, as when calling a builtin of that name, can also make mplc abort the same way or fail compilation with a wrong diagnostic. Make such a field the first name of its module, before any use, load that module before any other, pass no -D definition, and give the field a name that no builtin has.

A public overload can be selected directly by module loading. A private overload participates in same-name lookup only after its module has already been loaded through some other public name.

When followed by use, the pending specifier marks every directly imported name as an overload and clears when the import completes, including an empty import.

Behavior

• If another overload specifier is already pending in the same scope, using overload again is invalid.
• After the next successful local creation, the pending overload specifier is cleared.
• A pending overload specifier is invalid for importVariable.
• If the scope ends before the pending overload specifier is consumed, the program is invalid.
• Pending private or virtual coexist with the pending overload specifier.

Example

overloadExample.mpl

private overload virtual hiddenHelper: 3;
overload virtual helper: 1;
virtual publicAgain: 2;

test.mpl

"overloadExample.helper" use

{} 0 {} [
  "-- directly selected public overload --" printCompilerMessage
  helper printStack _:;
  0
] "main" exportFunction

Expected Output During Compilation

-- directly selected public overload --
1

indirectLookupExample.mpl

"overloadExample.publicAgain" use

{} 0 {} [
  "-- following created name is public --" printCompilerMessage
  publicAgain printStack _:;

  "-- public overload still participates in lookup --" printCompilerMessage
  helper printStack _:;

  "-- private overload also participates after module load --" printCompilerMessage
  hiddenHelper printStack _:;

  0
] "main" exportFunction

Expected Output During Compilation

-- following created name is public --
2
-- public overload still participates in lookup --
1
-- private overload also participates after module load --
3

See also

• NAME: ...; node — Pushes a name onto the name stack and creates a local by consuming that name and one data-stack object.
• def builtin (object name --) Creates a named local or field using a known Text name.
• exportFunction builtin (inputsSchema output options callable name --) Exports a named function built from a Block and a signature; pending overload applies there.
• importFunction builtin (inputsSchema output options name --) Declares or imports a named function with the supplied signature; pending overload applies there.
• importVariable builtin (schema name --) Creates a local that refers to external variable storage; pending overload is invalid there.
• private builtin (--) Marks the next local created by NAME: ...; or def as non-public, so use does not import that name from the module.
• virtual builtin (--) Marks the next local created by NAME: ...; or def as static; virtual is the historical name for this declaration modifier.