call · Builtins · MPL Reference

`call (inputs... callable -- outputs...)`

Inputs

inputs...: Objects required by callable, already below it in its required stack order.
callable: Already-selected object or Ref whose dereferenced schema is Block, Code, callable Dict, or known Text.

Outputs

outputs...: Zero or more objects left by callable, according to its own stack effect.

Calls one already-selected stack callable. No name lookup or field selection happens inside the builtin.

call performs a call boundary. Locals created inside the called logic do not remain available afterward.

Behavior

Stored Block, Code, and callable Dict objects are obtained via .@NAME or @NAME when the stored callable itself must be pushed. Plain .NAME or NAME calls the stored object at once, so runner call calls runner and then applies call to what it leaves. Known Text locals differ: plain mention already pushes the Text object, so textLocal call is valid.
For a callable Dict already on the data stack, its CALL field must have Block schema; call processes that Block directly. A Code-valued or other non-Block CALL is rejected. PRE is not used, because the Dict object is already selected before call runs.
Calling a Code that is not a known NIL — known non-NIL or unknown — is a run-time call; its outputs are unknown objects of the signature's output schema.
A known NIL Code is invalid.
Unknown Text is invalid.
A known NIL Text input is invalid.

When the input is a callable Dict, that callable Dict's fields are available for direct scope lookup during CALL. For a non-Meta non-static callable Dict supplied through a Ref — @NAME or .@NAME — call also introduces closure as a reference to that Dict with the same mutability, subject to normal name shadowing. A bare Dict supplies its fields but introduces no closure reference. Use @closure — for example, @closure.factor — because plain closure calls CALL again. There is no separate self name here, because no outer field-selection step occurs inside call.

Known Text inputs are interpreted as MPL code text and then called through the same call boundary.

Known issue: parsed Text bodies are cached by their contents. If identical Text is called from different modules, later processing can reuse the first call site's module for name lookup, so the result can depend on processing order. Use module-defined Blocks instead when names must resolve separately in each module.

Example

{} 0 {} [
  "-- block uses stack values below it --" printCompilerMessage
  5 [2 +] call printStack _:;

  "-- call uses CALL directly on an already selected Dict --" printCompilerMessage
  runner: {
    factor: 3;
    PRE: [FALSE];
    CALL: [factor *];
  };
  7 @runner call printStack _:;

  "-- read Code value first, then call it --" printCompilerMessage
  codeLocal: {} 0 {} codeRef;
  [42] !codeLocal # a non-NIL Code
  @codeLocal call printStack _:;

  "-- known text from stack --" printCompilerMessage
  9 «1 +» call printStack _:;

  "-- known text local may be mentioned plainly --" printCompilerMessage
  textLocal: «2 +»;
  8 textLocal call printStack _:;

  0
] "main" exportFunction

Expected Output During Compilation

-- block uses stack values below it --
7
-- call uses CALL directly on an already selected Dict --
21
-- read Code value first, then call it --
Int32
-- known text from stack --
10
-- known text local may be mentioned plainly --
10