nerdamer 2.0.0-rc.1 → 2.0.0

package/output/core/classes/parser/scripting/controlFlow.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContinueSignal = exports.BreakSignal = exports.ReturnSignal = exports.ControlFlowSignal = exports.CONTINUE_SIGNAL = exports.BREAK_SIGNAL = exports.RETURN_SIGNAL = void 0;
+exports.ReturnSignal = exports.NullSignal = exports.ControlFlowSignal = exports.ContinueSignal = exports.BreakSignal = exports.RETURN_SIGNAL = exports.NULL_SIGNAL = exports.CONTINUE_SIGNAL = exports.BREAK_SIGNAL = void 0;
+exports.isInsideSymbolicFunction = isInsideSymbolicFunction;
+exports.shouldConsumeLocalReturn = shouldConsumeLocalReturn;
+exports.withReturnPropagation = withReturnPropagation;
 exports.functionBoundary = functionBoundary;
 exports.RETURN = RETURN;
 exports.BREAK = BREAK;
@@ -17,77 +20,52 @@ exports.FOR = FOR;
 exports.BLOCK = BLOCK;
 exports.parserReturnBoundary = parserReturnBoundary;
 exports.parserBlock = parserBlock;
-const common_1 = require("../../../common/common");
 const errors_1 = require("../../../errors");
 const Settings_1 = require("../../../Settings");
 const Expression_1 = require("../../expression/Expression");
 const shortcuts_1 = require("../../expression/shortcuts");
-const Vector_1 = require("../../vector/Vector");
 const constants_1 = require("../constants");
-// Internal runtime tags for parser control-flow signals. These are not ParserEntity data types.
-exports.RETURN_SIGNAL = 'RETURN_SIGNAL';
-exports.BREAK_SIGNAL = 'BREAK_SIGNAL';
-exports.CONTINUE_SIGNAL = 'CONTINUE_SIGNAL';
-/** Base class for internal parser control transfers. These signals are not parser errors. */
-class ControlFlowSignal extends Error {
-    constructor() {
-        super();
-        this.name = new.target.name;
-    }
+const controlFlowSignals_1 = require("../controlFlowSignals");
+var controlFlowSignals_2 = require("../controlFlowSignals");
+Object.defineProperty(exports, "BREAK_SIGNAL", { enumerable: true, get: function () { return controlFlowSignals_2.BREAK_SIGNAL; } });
+Object.defineProperty(exports, "CONTINUE_SIGNAL", { enumerable: true, get: function () { return controlFlowSignals_2.CONTINUE_SIGNAL; } });
+Object.defineProperty(exports, "NULL_SIGNAL", { enumerable: true, get: function () { return controlFlowSignals_2.NULL_SIGNAL; } });
+Object.defineProperty(exports, "RETURN_SIGNAL", { enumerable: true, get: function () { return controlFlowSignals_2.RETURN_SIGNAL; } });
+Object.defineProperty(exports, "BreakSignal", { enumerable: true, get: function () { return controlFlowSignals_2.BreakSignal; } });
+Object.defineProperty(exports, "ContinueSignal", { enumerable: true, get: function () { return controlFlowSignals_2.ContinueSignal; } });
+Object.defineProperty(exports, "ControlFlowSignal", { enumerable: true, get: function () { return controlFlowSignals_2.ControlFlowSignal; } });
+Object.defineProperty(exports, "NullSignal", { enumerable: true, get: function () { return controlFlowSignals_2.NullSignal; } });
+Object.defineProperty(exports, "ReturnSignal", { enumerable: true, get: function () { return controlFlowSignals_2.ReturnSignal; } });
+const BREAK_SIGNAL_INSTANCE = new controlFlowSignals_1.BreakSignal();
+const CONTINUE_SIGNAL_INSTANCE = new controlFlowSignals_1.ContinueSignal();
+let loopBodyDepth = 0;
+let parserReturnBoundaryDepth = 0;
+let returnPropagationDepth = 0;
+let symbolicFunctionDepth = 0;
+function throwNullSignal() {
+    throw new controlFlowSignals_1.NullSignal();
 }
-exports.ControlFlowSignal = ControlFlowSignal;
-/**
- * Internal control-flow signal used to carry a symbolic function's return value to its
- * function boundary. It is not a mathematical parser result.
- */
-class ReturnSignal extends ControlFlowSignal {
-    value;
-    dataType = exports.RETURN_SIGNAL;
-    constructor(value) {
-        super();
-        this.value = value;
-    }
-    static isReturnSignal(obj) {
-        return (0, common_1.isNerdamerNativeType)(obj, exports.RETURN_SIGNAL);
-    }
+function isInsideSymbolicFunction() {
+    return symbolicFunctionDepth > 0;
 }
-exports.ReturnSignal = ReturnSignal;
-/** Internal control-flow signal consumed by the nearest parser loop. */
-class BreakSignal extends ControlFlowSignal {
-    dataType = exports.BREAK_SIGNAL;
-    static isBreakSignal(obj) {
-        return (0, common_1.isNerdamerNativeType)(obj, exports.BREAK_SIGNAL);
-    }
+function shouldConsumeLocalReturn() {
+    return symbolicFunctionDepth === 0 && returnPropagationDepth === 0;
 }
-exports.BreakSignal = BreakSignal;
-/** Internal control-flow signal consumed by the nearest parser loop. */
-class ContinueSignal extends ControlFlowSignal {
-    dataType = exports.CONTINUE_SIGNAL;
-    static isContinueSignal(obj) {
-        return (0, common_1.isNerdamerNativeType)(obj, exports.CONTINUE_SIGNAL);
+function withReturnPropagation(evaluate) {
+    returnPropagationDepth++;
+    try {
+        return evaluate();
+    }
+    finally {
+        returnPropagationDepth--;
     }
 }
-exports.ContinueSignal = ContinueSignal;
-// BREAK and CONTINUE carry no data, so reuse their signals instead of allocating an Error
-// on every control transfer. RETURN carries a value and therefore remains per invocation.
-const BREAK_SIGNAL_INSTANCE = new BreakSignal();
-const CONTINUE_SIGNAL_INSTANCE = new ContinueSignal();
-// Parser control flow is synchronous. Track active execution boundaries so internal signals
-// are consumed by the correct parser construct without leaking across function calls.
-let loopBodyDepth = 0;
-let parserReturnBoundaryDepth = 0;
-let symbolicFunctionDepth = 0;
-/** Returns the parser's boolean interpretation of one evaluated condition. */
 function isTruthy(value) {
     if (!Expression_1.Expression.isExpression(value)) {
         throw new errors_1.UnexpectedDataType((0, errors_1.message)('expressionExpected', { type: constants_1.dataTypes[value.dataType] }));
     }
     return !value.isZero();
 }
-/**
- * Evaluates one symbolic-function body and consumes control flow at the function boundary.
- * RETURN becomes the function result, while BREAK and CONTINUE cannot escape a function call.
- */
 function functionBoundary(evaluate) {
     let retval;
     symbolicFunctionDepth++;
@@ -95,13 +73,13 @@ function functionBoundary(evaluate) {
         retval = evaluate();
     }
     catch (error) {
-        if (ReturnSignal.isReturnSignal(error)) {
+        if (controlFlowSignals_1.ReturnSignal.isReturnSignal(error)) {
             retval = error.value;
         }
-        else if (BreakSignal.isBreakSignal(error)) {
+        else if (controlFlowSignals_1.BreakSignal.isBreakSignal(error)) {
             throw new errors_1.ParserError((0, errors_1.message)('breakOutsideLoop'));
         }
-        else if (ContinueSignal.isContinueSignal(error)) {
+        else if (controlFlowSignals_1.ContinueSignal.isContinueSignal(error)) {
             throw new errors_1.ParserError((0, errors_1.message)('continueOutsideLoop'));
         }
         else {
@@ -113,32 +91,21 @@ function functionBoundary(evaluate) {
     }
     return retval;
 }
-/**
- * Returns a value from the current symbolic function.
- * @param x
- * @returns
- */
 function RETURN(x) {
-    throw new ReturnSignal(x);
+    throw new controlFlowSignals_1.ReturnSignal(x);
 }
-/** Exits the nearest parser control-flow loop. */
 function BREAK() {
     if (loopBodyDepth === 0) {
         throw new errors_1.ParserError((0, errors_1.message)('breakOutsideLoop'));
     }
     throw BREAK_SIGNAL_INSTANCE;
 }
-/** Skips to the next iteration of the nearest parser control-flow loop. */
 function CONTINUE() {
     if (loopBodyDepth === 0) {
         throw new errors_1.ParserError((0, errors_1.message)('continueOutsideLoop'));
     }
     throw CONTINUE_SIGNAL_INSTANCE;
 }
-/**
- * Returns 1 when every deferred argument is nonzero, otherwise 0.
- * Evaluation stops as soon as a false argument is found.
- */
 function AND(...args) {
     let retval = (0, shortcuts_1.one)();
     for (const arg of args) {
@@ -149,10 +116,6 @@ function AND(...args) {
     }
     return retval;
 }
-/**
- * Returns 1 when at least one deferred argument is nonzero, otherwise 0.
- * Evaluation stops as soon as a true argument is found.
- */
 function OR(...args) {
     let retval = (0, shortcuts_1.zero)();
     for (const arg of args) {
@@ -163,12 +126,9 @@ function OR(...args) {
     }
     return retval;
 }
-/** Returns 1 when the argument is zero and 0 otherwise. */
 function NOT(value) {
-    const retval = isTruthy(value) ? (0, shortcuts_1.zero)() : (0, shortcuts_1.one)();
-    return retval;
+    return isTruthy(value) ? (0, shortcuts_1.zero)() : (0, shortcuts_1.one)();
 }
-/** Returns 1 when an odd number of arguments are nonzero, otherwise 0. */
 function XOR(...args) {
     let odd = false;
     for (const arg of args) {
@@ -176,159 +136,148 @@ function XOR(...args) {
             odd = !odd;
         }
     }
-    const retval = odd ? (0, shortcuts_1.one)() : (0, shortcuts_1.zero)();
-    return retval;
+    return odd ? (0, shortcuts_1.one)() : (0, shortcuts_1.zero)();
 }
-/**
- * Evaluates an expression and returns its result unless evaluation throws an ordinary error.
- * The fallback is evaluated only after an error. Internal parser control-flow signals continue
- * unwinding to their enclosing function or loop boundary.
- */
 function IFERROR(expression, fallback) {
     let retval;
     try {
         retval = expression();
     }
     catch (error) {
-        if (error instanceof ControlFlowSignal) {
+        if (error instanceof controlFlowSignals_1.ControlFlowSignal) {
             throw error;
         }
         retval = fallback();
     }
     return retval;
 }
-/**
- * Returns 1 when deferred evaluation throws an ordinary error and 0 otherwise.
- * Internal parser control-flow signals are not errors and continue unwinding normally.
- */
 function ISERROR(expression) {
     let retval = (0, shortcuts_1.zero)();
     try {
         expression();
     }
     catch (error) {
-        if (error instanceof ControlFlowSignal) {
+        if (error instanceof controlFlowSignals_1.ControlFlowSignal) {
             throw error;
         }
         retval = (0, shortcuts_1.one)();
     }
     return retval;
 }
-/**
- * A branching function. Its arguments are deferred so only the selected branch is evaluated.
- * When the false branch is omitted, a false condition produces the parser's empty result.
- * @param condition
- * @param branch1
- * @param branch2
- * @returns
- */
-function IF(condition, branch1, branch2) {
-    const evaluatedCondition = condition();
+function controlFlowReturnBoundary(evaluate) {
     let retval;
-    if (isTruthy(evaluatedCondition)) {
-        retval = branch1();
+    try {
+        retval = evaluate();
     }
-    else {
-        retval = branch2 ? branch2() : new Vector_1.Vector();
+    catch (error) {
+        if (parserReturnBoundaryDepth > 0 &&
+            shouldConsumeLocalReturn() &&
+            controlFlowSignals_1.ReturnSignal.isReturnSignal(error)) {
+            retval = error.value;
+        }
+        else {
+            throw error;
+        }
     }
     return retval;
 }
-/**
- * Repeatedly evaluates a deferred body while a deferred condition is nonzero.
- * The condition is reevaluated before every iteration. BREAK and CONTINUE are consumed here so
- * they apply only to the nearest loop; other control-flow signals continue to unwind outward.
- * The final completed body result is returned; if the body never completes, an empty Vector is
- * returned.
- * @param condition
- * @param body
- * @returns
- */
-function WHILE(condition, body) {
-    let retval = new Vector_1.Vector();
-    let continueLoop = true;
-    let iterations = 0;
-    while (continueLoop) {
+function IF(condition, branch1, branch2) {
+    return controlFlowReturnBoundary(() => {
         const evaluatedCondition = condition();
-        if (!isTruthy(evaluatedCondition)) {
-            continueLoop = false;
+        let retval;
+        if (isTruthy(evaluatedCondition)) {
+            retval = branch1();
+        }
+        else if (branch2) {
+            retval = branch2();
         }
         else {
-            if (iterations >= Settings_1.Settings.MAX_LOOP_ITERATIONS) {
-                throw new errors_1.ParserError((0, errors_1.message)('loopIterationLimitExceeded', {
-                    max: String(Settings_1.Settings.MAX_LOOP_ITERATIONS),
-                }));
-            }
-            loopBodyDepth++;
-            try {
-                retval = body();
+            return throwNullSignal();
+        }
+        return retval;
+    });
+}
+function WHILE(condition, body) {
+    return controlFlowReturnBoundary(() => {
+        let retval;
+        let continueLoop = true;
+        let iterations = 0;
+        while (continueLoop) {
+            const evaluatedCondition = condition();
+            if (!isTruthy(evaluatedCondition)) {
+                continueLoop = false;
             }
-            catch (error) {
-                if (BreakSignal.isBreakSignal(error)) {
-                    continueLoop = false;
+            else {
+                if (iterations >= Settings_1.Settings.MAX_LOOP_ITERATIONS) {
+                    throw new errors_1.ParserError((0, errors_1.message)('loopIterationLimitExceeded', { max: String(Settings_1.Settings.MAX_LOOP_ITERATIONS) }));
                 }
-                else if (!ContinueSignal.isContinueSignal(error)) {
-                    throw error;
+                loopBodyDepth++;
+                try {
+                    retval = body();
                 }
+                catch (error) {
+                    if (controlFlowSignals_1.NullSignal.isNullSignal(error)) {
+                        // A loop body may legitimately complete without producing a value.
+                    }
+                    else if (controlFlowSignals_1.BreakSignal.isBreakSignal(error)) {
+                        continueLoop = false;
+                    }
+                    else if (!controlFlowSignals_1.ContinueSignal.isContinueSignal(error)) {
+                        throw error;
+                    }
+                }
+                finally {
+                    loopBodyDepth--;
+                }
+                iterations++;
             }
-            finally {
-                loopBodyDepth--;
-            }
-            iterations++;
         }
-    }
-    return retval;
+        if (retval === undefined) {
+            return throwNullSignal();
+        }
+        return retval;
+    });
 }
-/**
- * Evaluates a deferred initializer once, then delegates repeated condition and body evaluation
- * to WHILE. The update runs after each completed body evaluation and also before a CONTINUE
- * advances to the next condition check. BREAK and RETURN skip the pending update. The final
- * completed body result is returned; if the body never completes, WHILE's empty-Vector result
- * is preserved.
- * @param initializer
- * @param condition
- * @param update
- * @param body
- * @returns
- */
 function FOR(initializer, condition, update, body) {
-    initializer();
-    const retval = WHILE(condition, () => {
-        let bodyResult;
-        try {
-            bodyResult = body();
-        }
-        catch (error) {
-            if (ContinueSignal.isContinueSignal(error)) {
-                update();
+    return controlFlowReturnBoundary(() => {
+        initializer();
+        return WHILE(condition, () => {
+            let bodyResult;
+            try {
+                bodyResult = body();
             }
-            throw error;
-        }
-        update();
-        return bodyResult;
+            catch (error) {
+                if (controlFlowSignals_1.ContinueSignal.isContinueSignal(error) ||
+                    controlFlowSignals_1.NullSignal.isNullSignal(error)) {
+                    update();
+                }
+                throw error;
+            }
+            update();
+            return bodyResult;
+        });
     });
-    return retval;
 }
-/**
- * Evaluates a sequence of deferred parser commands in order.
- * The final command's result is returned. Control-flow signals are not consumed here, allowing
- * RETURN, BREAK, and CONTINUE to unwind to their enclosing function or loop boundary. An empty
- * block retains the historical empty-vector result.
- * @param args
- * @returns
- */
 function BLOCK(...args) {
-    let retval = new Vector_1.Vector();
+    if (args.length === 0) {
+        return throwNullSignal();
+    }
+    let retval;
     for (const arg of args) {
-        retval = arg();
+        try {
+            retval = arg();
+        }
+        catch (error) {
+            if (!controlFlowSignals_1.NullSignal.isNullSignal(error)) {
+                throw error;
+            }
+        }
+    }
+    if (retval === undefined) {
+        return throwNullSignal();
     }
     return retval;
 }
-/**
- * Evaluates one parser-dispatched function through the outer return boundary.
- *
- * Nested parser calls keep propagating RETURN. The outermost parser call consumes it when
- * execution is not already inside a symbolic function.
- */
 function parserReturnBoundary(evaluate) {
     const consumesReturn = symbolicFunctionDepth === 0 && parserReturnBoundaryDepth === 0;
     let retval;
@@ -337,7 +286,7 @@ function parserReturnBoundary(evaluate) {
         retval = evaluate();
     }
     catch (error) {
-        if (consumesReturn && ReturnSignal.isReturnSignal(error)) {
+        if (consumesReturn && controlFlowSignals_1.ReturnSignal.isReturnSignal(error)) {
             retval = error.value;
         }
         else {
@@ -349,7 +298,6 @@ function parserReturnBoundary(evaluate) {
     }
     return retval;
 }
-/** Evaluates BLOCK through the parser return boundary. */
 function parserBlock(...args) {
     return parserReturnBoundary(() => BLOCK(...args));
 }

package/output/core/classes/parser/scripting/deferred.d.ts

@@ -0,0 +1,4 @@
+import type { ParserEntity } from '../../../types';
+import type { DeferredFunctionArgument } from '../types';
+/** Iterates parser containers while keeping iteration variables local to each body call. */
+export declare function each(collection: DeferredFunctionArgument, variable: DeferredFunctionArgument, bodyOrValueVariable: DeferredFunctionArgument, dictionaryBody?: DeferredFunctionArgument): ParserEntity;

package/output/core/classes/parser/scripting/deferred.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.each = each;
+const errors_1 = require("../../../errors");
+const Collection_1 = require("../../collection/Collection");
+const Dictionary_1 = require("../../dictionary/Dictionary");
+const Expression_1 = require("../../expression/Expression");
+const shortcuts_1 = require("../../expression/shortcuts");
+const Matrix_1 = require("../../matrix/Matrix");
+const ValuesSet_1 = require("../../valuesSet/ValuesSet");
+const Vector_1 = require("../../vector/Vector");
+const constants_1 = require("../constants");
+const controlFlow_1 = require("./controlFlow");
+const scope_1 = require("./scope");
+/** Iterates parser containers while keeping iteration variables local to each body call. */
+function each(collection, variable, bodyOrValueVariable, dictionaryBody) {
+    const target = collection();
+    const values = [];
+    const keys = [];
+    if (dictionaryBody) {
+        if (!Dictionary_1.Dictionary.isDictionary(target)) {
+            throw new errors_1.UnexpectedDataType((0, errors_1.message)('unsupportedType', { type: constants_1.dataTypes[target.dataType] }));
+        }
+        for (const [key, value] of target.entries()) {
+            keys.push(Expression_1.Expression.create(key));
+            values.push(value.copy());
+        }
+    }
+    else if (Vector_1.Vector.isVector(target) ||
+        Collection_1.Collection.isCollection(target) ||
+        ValuesSet_1.ValuesSet.isValuesSet(target)) {
+        target.forEach(value => values.push(value.copy()));
+    }
+    else if (Matrix_1.Matrix.isMatrix(target)) {
+        target.forEach(value => values.push(value.copy()));
+    }
+    else if (Dictionary_1.Dictionary.isDictionary(target)) {
+        target.forEach(value => values.push(value.copy()));
+    }
+    else {
+        throw new errors_1.UnexpectedDataType((0, errors_1.message)('unsupportedType', { type: constants_1.dataTypes[target.dataType] }));
+    }
+    let index = 0;
+    let retval;
+    try {
+        retval = (0, controlFlow_1.withReturnPropagation)(() => (0, controlFlow_1.FOR)(() => (0, shortcuts_1.zero)(), () => (index < values.length ? (0, shortcuts_1.one)() : (0, shortcuts_1.zero)()), () => {
+            index++;
+            return (0, shortcuts_1.zero)();
+        }, () => {
+            if (dictionaryBody) {
+                return (0, scope_1.LET)(variable, () => keys[index], () => (0, scope_1.LET)(bodyOrValueVariable, () => values[index], dictionaryBody));
+            }
+            return (0, scope_1.LET)(variable, () => values[index], bodyOrValueVariable);
+        }));
+    }
+    catch (error) {
+        if (!(0, controlFlow_1.isInsideSymbolicFunction)() && controlFlow_1.ReturnSignal.isReturnSignal(error)) {
+            retval = error.value;
+        }
+        else {
+            throw error;
+        }
+    }
+    return retval;
+}

package/output/core/classes/parser/scripting/dispatch.d.ts

@@ -0,0 +1 @@
+export declare function loadScriptingFunctions(): void;

package/output/core/classes/parser/scripting/dispatch.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadScriptingFunctions = loadScriptingFunctions;
+const dispatch_1 = require("../../../dispatch");
+const controlFlow_1 = require("./controlFlow");
+const deferred_1 = require("./deferred");
+const evaluate_1 = require("./evaluate");
+const scope_1 = require("./scope");
+function loadScriptingFunctions() {
+    Object.assign(dispatch_1.mathFunctionRegistry, {
+        unassign: (0, dispatch_1.systemFunction)({ fn: scope_1.unassign, minArgs: 1, maxArgs: 1, distElWise: false, deferArguments: true }),
+        evaluate: (0, dispatch_1.systemFunction)({
+            fn: evaluate_1.evaluate,
+            minArgs: 1,
+            maxArgs: 3,
+            equationArgs: [0],
+            distElWise: false,
+            deferArguments: true,
+            usage: 'scripting',
+        }),
+        return: (0, dispatch_1.systemFunction)({
+            fn: controlFlow_1.RETURN,
+            minArgs: 1,
+            maxArgs: 1,
+            equationArgs: [0],
+            distElWise: false,
+            bracketlessStatement: true,
+            usage: 'scripting',
+        }),
+        break: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.BREAK, minArgs: 0, maxArgs: 0, distElWise: false, usage: 'scripting' }),
+        continue: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.CONTINUE, minArgs: 0, maxArgs: 0, distElWise: false, usage: 'scripting' }),
+        and: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.AND, minArgs: 2, maxArgs: -1, distElWise: false, deferArguments: true, usage: 'scripting' }),
+        or: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.OR, minArgs: 2, maxArgs: -1, distElWise: false, deferArguments: true, usage: 'scripting' }),
+        not: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.NOT, minArgs: 1, maxArgs: 1, distElWise: false, usage: 'scripting' }),
+        xor: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.XOR, minArgs: 2, maxArgs: -1, distElWise: false, usage: 'scripting' }),
+        iferror: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.IFERROR, minArgs: 2, maxArgs: 2, distElWise: false, deferArguments: true, usage: 'scripting' }),
+        iserror: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.ISERROR, minArgs: 1, maxArgs: 1, distElWise: false, deferArguments: true, usage: 'scripting' }),
+        if: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.IF, minArgs: 2, maxArgs: 3, distElWise: false, deferArguments: true, returnBoundary: true, usage: 'scripting' }),
+        while: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.WHILE, minArgs: 2, maxArgs: 2, distElWise: false, deferArguments: true, returnBoundary: true, usage: 'scripting' }),
+        for: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.FOR, minArgs: 4, maxArgs: 4, distElWise: false, deferArguments: true, returnBoundary: true, usage: 'scripting' }),
+        each: (0, dispatch_1.systemFunction)({ fn: deferred_1.each, minArgs: 3, maxArgs: 4, distElWise: false, deferArguments: true, usage: 'scripting' }),
+        let: (0, dispatch_1.systemFunction)({
+            fn: scope_1.LET,
+            minArgs: 3,
+            maxArgs: -1,
+            distElWise: false,
+            deferArguments: true,
+            normalizeDeferredArguments: scope_1.normalizeLetArguments,
+            returnBoundary: true,
+            usage: 'scripting',
+        }),
+        block: (0, dispatch_1.systemFunction)({
+            fn: controlFlow_1.BLOCK,
+            minArgs: -1,
+            maxArgs: -1,
+            distElWise: false,
+            deferArguments: true,
+            returnBoundary: true,
+            usage: 'scripting',
+        }),
+    });
+}

package/output/core/classes/parser/scripting/evaluate.d.ts

@@ -2,6 +2,19 @@ import type { ParserEntity } from '../../../types';
 import type { DeferredFunctionArgument } from '../types';
 /**
  * Evaluates a deferred parser value and returns the resolved input if evaluation cannot complete.
+ *
+ * @remarks
+ * A Dictionary supplied as the second argument provides substitutions for this evaluation only.
+ * Those names are passed through the same call-scoped parser-value mechanism used by
+ * `Parser.parse(..., values)`; they are not written to the parser's known-value table.
+ *
+ * This distinction matters for reserved names. The solver index `_n` cannot be assigned
+ * globally with `_n: value`, but it can be supplied locally when evaluating a parametric
+ * `SolutionSet`. For example, `evaluate(solve(sin(x),x),{_n=>0})` returns `{0}`.
+ *
+ * When a solver result is stored first in Nerdamer Scripting, use `:` for assignment:
+ * `sol: solve(sin(x),x); evaluate(sol,{_n=>0})`. The `=` operator denotes an equation;
+ * it does not store a parser value in a variable.
  */
 export declare function evaluate(value: DeferredFunctionArgument, substitutions?: DeferredFunctionArgument, point?: DeferredFunctionArgument): ParserEntity;
 /**

package/output/core/classes/parser/scripting/evaluate.js

@@ -16,6 +16,19 @@ const constants_1 = require("../constants");
 const EVALUATE_FUNCTION = 'evaluate';
 /**
  * Evaluates a deferred parser value and returns the resolved input if evaluation cannot complete.
+ *
+ * @remarks
+ * A Dictionary supplied as the second argument provides substitutions for this evaluation only.
+ * Those names are passed through the same call-scoped parser-value mechanism used by
+ * `Parser.parse(..., values)`; they are not written to the parser's known-value table.
+ *
+ * This distinction matters for reserved names. The solver index `_n` cannot be assigned
+ * globally with `_n: value`, but it can be supplied locally when evaluating a parametric
+ * `SolutionSet`. For example, `evaluate(solve(sin(x),x),{_n=>0})` returns `{0}`.
+ *
+ * When a solver result is stored first in Nerdamer Scripting, use `:` for assignment:
+ * `sol: solve(sin(x),x); evaluate(sol,{_n=>0})`. The `=` operator denotes an equation;
+ * it does not store a parser value in a variable.
  */
 function evaluate(value, substitutions, point) {
     const input = value();
@@ -54,7 +67,10 @@ function evaluate(value, substitutions, point) {
     let retval = input;
     try {
         if (values &&
-            (Expression_1.Expression.isExpression(input) || Vector_1.Vector.isVector(input) || Matrix_1.Matrix.isMatrix(input))) {
+            (Expression_1.Expression.isExpression(input) ||
+                Vector_1.Vector.isVector(input) ||
+                Matrix_1.Matrix.isMatrix(input) ||
+                ValuesSet_1.ValuesSet.isValuesSet(input))) {
             retval = input.evaluate(values);
         }
         else {