mimo-lang 1.1.0 → 2.0.6

package/interpreter/executors/PatternMatchExecutor.js

@@ -0,0 +1,93 @@
+import { ErrorHandler } from "../ErrorHandler.js";
+import { Environment } from "../environment.js";
+import { stringify, isTruthy } from "../Utils.js";
+import { BaseExecutor } from "./BaseExecutor.js";
+
+export class PatternMatchExecutor extends BaseExecutor {
+  executeMatchStatement(node) {
+    const discriminant = this.interpreter.visitNode(node.discriminant);
+
+    for (const caseClause of node.cases) {
+      const bindings = {};
+      // The `matchesPattern` method might throw if a pattern is invalid, let it bubble up.
+      if (this.matchesPattern(discriminant, caseClause.pattern, bindings)) {
+        // Create new block scope for case body
+        const caseEnv = new Environment(this.interpreter.currentEnv);
+
+        // Bind all captured variables to the case scope
+        for (const [name, value] of Object.entries(bindings)) {
+          // Define the variable in the case's scope
+          // Default to 'let' kind for bindings, but could be configurable
+          caseEnv.define(name, value, "let"); // Assume 'let' kind for pattern bindings
+        }
+
+        let guardPassed = true;
+        if (caseClause.guard) {
+          const previousEnv = this.interpreter.currentEnv;
+          this.interpreter.currentEnv = caseEnv;
+          try {
+            guardPassed = isTruthy(this.interpreter.visitNode(caseClause.guard));
+          } finally {
+            this.interpreter.currentEnv = previousEnv;
+          }
+        }
+
+        if (guardPassed) {
+          return this.interpreter.executeBlock(caseClause.consequent, caseEnv);
+        }
+      }
+    }
+
+    // No match found and no default case
+    throw this.interpreter.errorHandler.createRuntimeError(
+      `No matching pattern found for value: ${stringify(discriminant)}`,
+      node.discriminant, // Point to the discriminant expression
+      "MATCH001",
+      `Add an 'default:' clause or ensure all possible values are covered by 'case' clauses.`
+    );
+  }
+
+  matchesPattern(value, pattern, bindings = {}) {
+    // Default case (pattern is null)
+    if (pattern === null) {
+      return true;
+    }
+
+    switch (pattern.type) {
+      case "Literal":
+        return value === pattern.value;
+
+      case "Identifier":
+        // Identifier patterns always match and bind the value
+        bindings[pattern.name] = value;
+        return true;
+
+      case "ArrayPattern":
+        if (!Array.isArray(value)) {
+          return false;
+        }
+
+        // Check if array length matches
+        if (value.length !== pattern.elements.length) {
+          return false;
+        }
+
+        // Check each element and collect bindings
+        for (let i = 0; i < pattern.elements.length; i++) {
+          if (!this.matchesPattern(value[i], pattern.elements[i], bindings)) {
+            return false;
+          }
+        }
+        return true;
+
+      // TODO: Add ObjectPattern, TypePattern etc.
+      default:
+        throw this.interpreter.errorHandler.createRuntimeError(
+          `Internal error: Unknown pattern type '${pattern.type}' encountered during matching.`,
+          pattern, // The AST node for the problematic pattern
+          "INT003",
+          "This indicates a bug in the Mimo interpreter. Please report this error."
+        );
+    }
+  }
+}

package/interpreter/executors/VariableExecutor.js

@@ -0,0 +1,144 @@
+// In: interpreter/executors/VariableExecutor.js
+
+import { ErrorHandler } from "../ErrorHandler.js";
+import { Environment } from "../environment.js";
+import { BaseExecutor } from "./BaseExecutor.js";
+
+export class VariableExecutor extends BaseExecutor {
+  executeVariableDeclaration(node) {
+    const value = this.interpreter.visitNode(node.value);
+
+    const defineOrAssign = (varName, varValue) => {
+      switch (node.kind) {
+        case "global":
+          this.interpreter.globalEnv.define(varName, varValue, 'global');
+          break;
+        case "let":
+        case "const":
+          this.interpreter.currentEnv.define(varName, varValue, node.kind);
+          break;
+        default: // 'set'
+          const existingVarInfo = this.interpreter.currentEnv.getVariableInfo(varName);
+          if (existingVarInfo) {
+            try {
+              existingVarInfo.env.assign(varName, varValue);
+            } catch (error) {
+              throw this.interpreter.errorHandler.createRuntimeError(
+                error.message,
+                node,
+                "TYPE002",
+                "Verify variable mutability and declaration scope."
+              );
+            }
+          } else {
+            this.interpreter.currentEnv.define(varName, varValue, 'set');
+          }
+          break;
+      }
+    };
+
+    if (typeof node.identifier === "object" && node.identifier !== null && node.identifier.type.endsWith("Pattern")) {
+      const pattern = node.identifier;
+      if (pattern.type === 'ArrayPattern') {
+        if (!Array.isArray(value)) {
+          throw this.interpreter.errorHandler.createRuntimeError(`Cannot destructure non-array value into an array pattern.`, node.value, 'TYPE002');
+        }
+        pattern.elements.forEach((varNode, i) => {
+          defineOrAssign(varNode.name, value[i] ?? null);
+        });
+      } else if (pattern.type === 'ObjectPattern') {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+          throw this.interpreter.errorHandler.createRuntimeError(`Cannot destructure non-object value into an object pattern.`, node.value, 'TYPE002');
+        }
+        pattern.properties.forEach(propIdentifierNode => {
+          const propName = propIdentifierNode.name;
+          defineOrAssign(propName, value[propName] ?? null);
+        });
+      }
+      return value;
+    }
+
+    defineOrAssign(node.identifier, value);
+    return value;
+  }
+
+  executePropertyAssignment(node) {
+    const targetObject = this.interpreter.visitNode(node.object);
+    const valueToAssign = this.interpreter.visitNode(node.value);
+
+    if (targetObject === null || typeof targetObject !== 'object') {
+      throw this.interpreter.errorHandler.createRuntimeError(
+        `Cannot set property '${node.property}' on a non-object value (got ${typeof targetObject}).`,
+        node.object, "TYPE004", "Ensure the target is an object before setting its properties."
+      );
+    }
+    targetObject[node.property] = valueToAssign;
+    return valueToAssign;
+  }
+
+  executeBracketAssignment(node) {
+    const object = this.interpreter.visitNode(node.object);
+    const index = this.interpreter.visitNode(node.index);
+    const value = this.interpreter.visitNode(node.value);
+
+    if (Array.isArray(object)) {
+      if (typeof index !== "number" || !Number.isInteger(index)) {
+        throw this.interpreter.errorHandler.createRuntimeError(`Array index for assignment must be an integer. Got '${typeof index}'.`, node.index, "TYPE001");
+      }
+      if (index < 0) {
+        throw this.interpreter.errorHandler.createRuntimeError(`Array index cannot be negative. Got ${index}.`, node.index, "INDEX001");
+      }
+      object[index] = value;
+      return value;
+    }
+
+    if (typeof object === "object" && object !== null) {
+      const key = String(index);
+      object[key] = value;
+      return value;
+    }
+
+    throw this.interpreter.errorHandler.createRuntimeError(`Cannot set property on value of type '${typeof object}'.`, node.object, "TYPE002");
+  }
+
+  executeDestructuringAssignment(node) {
+    const value = this.interpreter.visitNode(node.expression);
+    const pattern = node.pattern; // The pattern node is now passed directly
+
+    // Helper function to assign a value to a variable using 'set' semantics
+    const assignOrDefine = (varNode, varValue) => {
+      const varName = varNode.name;
+      const existingVarInfo = this.interpreter.currentEnv.getVariableInfo(varName);
+      if (existingVarInfo) {
+        existingVarInfo.env.assign(varName, varValue);
+      } else {
+        this.interpreter.currentEnv.define(varName, varValue, 'set');
+      }
+    };
+
+    // --- Main Logic ---
+
+    if (pattern.type === 'ArrayPattern') {
+      if (!Array.isArray(value)) {
+        throw this.interpreter.errorHandler.createRuntimeError(`Cannot destructure non-array value into an array pattern.`, node.expression, 'TYPE002');
+      }
+      pattern.elements.forEach((varNode, i) => {
+        assignOrDefine(varNode, value[i] ?? null); // Assign null if index is out of bounds
+      });
+    } else if (pattern.type === 'ObjectPattern') {
+      if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw this.interpreter.errorHandler.createRuntimeError(`Cannot destructure non-object value into an object pattern.`, node.expression, 'TYPE002');
+      }
+      pattern.properties.forEach(propIdentifierNode => {
+        const propName = propIdentifierNode.name;
+        // Assign the property's value, or null if it doesn't exist on the object
+        assignOrDefine(propIdentifierNode, value[propName] ?? null);
+      });
+    } else {
+      // This case should be unreachable if the parser is correct
+      throw this.interpreter.errorHandler.createRuntimeError(`Unsupported pattern type '${pattern.type}' for destructuring.`, pattern, 'INT003');
+    }
+
+    return value; // The destructuring statement itself returns the original value
+  }
+}

package/interpreter/index.js

@@ -0,0 +1,8 @@
+export { Interpreter } from './Interpreter.js';
+export { Environment } from './environment.js';
+export { ReturnValue, FunctionValue } from './Values.js';
+export { ExpressionEvaluator } from './ExpressionEvaluator.js';
+export { StatementExecutor } from './StatementExecutor.js';
+export { isTruthy, stringify } from './Utils.js';
+export { BuiltinFunction } from './BuiltinFunction.js';
+export { builtinFunctions, initializeBuiltins } from './coreBuiltins.js';

package/interpreter/stdlib/array/accessFunctions.js

@@ -0,0 +1,61 @@
+import { BuiltinFunction } from '../../BuiltinFunction.js';
+import { expectArray, expectNumber } from './arrayUtils.js';
+
+// --- Access and Extraction Functions ---
+
+export const arraySlice = new BuiltinFunction("slice",
+    (args, interpreter, callNode) => {
+        const [arr, beginIndexArg, endIndexArg] = args;
+        expectArray(arr, "slice", interpreter, callNode, 1);
+
+        let beginIndex = 0;
+        // If beginIndexArg is provided and NOT null, then validate it as a number.
+        if (beginIndexArg !== undefined && beginIndexArg !== null) {
+            expectNumber(beginIndexArg, "slice", interpreter, callNode, 2);
+            beginIndex = beginIndexArg;
+        }
+        // If beginIndexArg IS undefined or null, beginIndex remains its default (0).
+
+        let endIndex = arr.length;
+        // If endIndexArg is provided and NOT null, then validate it as a number.
+        if (endIndexArg !== undefined && endIndexArg !== null) {
+            expectNumber(endIndexArg, "slice", interpreter, callNode, 3);
+            endIndex = endIndexArg;
+        }
+        // If endIndexArg IS undefined or null, endIndex remains its default (arr.length).
+
+        // The native JavaScript Array.prototype.slice method already handles
+        // undefined/null for its arguments gracefully, so we can pass `beginIndex`
+        // and `endIndex` directly.
+        // Note: JS `slice` also handles negative indices which is great for your test.
+        return arr.slice(beginIndex, endIndex);
+    },
+    [1, 3] // array, [beginIndex], [endIndex] - arity remains 1 to 3
+);
+
+export const arrayFirst = new BuiltinFunction("first",
+    (args, interpreter, callNode) => {
+        const [arr] = args;
+        expectArray(arr, "first", interpreter, callNode, 1);
+        return arr.length > 0 ? arr[0] : null;
+    },
+    1
+);
+
+export const arrayLast = new BuiltinFunction("last",
+    (args, interpreter, callNode) => {
+        const [arr] = args;
+        expectArray(arr, "last", interpreter, callNode, 1);
+        return arr.length > 0 ? arr[arr.length - 1] : null;
+    },
+    1
+);
+
+export const arrayIsEmpty = new BuiltinFunction("is_empty",
+    (args, interpreter, callNode) => {
+        const [arr] = args;
+        expectArray(arr, "is_empty", interpreter, callNode, 1);
+        return arr.length === 0;
+    },
+    1
+);

package/interpreter/stdlib/array/arrayUtils.js

@@ -0,0 +1,36 @@
+import { FunctionValue } from '../../Values.js';
+
+// --- Helper for type checking ---
+export function expectArray(arg, funcName, interpreter, callNode, argPosition = 1) {
+    if (!Array.isArray(arg)) {
+        throw interpreter.errorHandler.createRuntimeError(
+            `${funcName}() expects an array as argument ${argPosition}. Got '${typeof arg}'.`,
+            callNode,
+            'TYPE001',
+            `Ensure argument ${argPosition} for '${funcName}' is an array.`
+        );
+    }
+}
+
+export function expectMimoFunction(arg, funcName, interpreter, callNode, argPosition = 1) {
+    if (!(arg instanceof FunctionValue)) {
+        throw interpreter.errorHandler.createRuntimeError(
+            `${funcName}() expects a Mimo function as argument ${argPosition}. Got '${typeof arg}'.`,
+            callNode,
+            'TYPE001',
+            `Ensure argument ${argPosition} for '${funcName}' is a function.`
+        );
+    }
+}
+
+// Helper for number type checking
+export function expectNumber(arg, funcName, interpreter, callNode, argPosition = 1) {
+    if (typeof arg !== 'number') {
+        throw interpreter.errorHandler.createRuntimeError(
+            `${funcName}() expects a number as argument ${argPosition}. Got '${typeof arg}'.`,
+            callNode,
+            'TYPE001',
+            `Ensure argument ${argPosition} for '${funcName}' is a number.`
+        );
+    }
+}

package/interpreter/stdlib/array/higherOrderFunctions.js

@@ -0,0 +1,285 @@
+import { BuiltinFunction } from '../../BuiltinFunction.js';
+import { expectArray, expectMimoFunction } from './arrayUtils.js';
+
+// --- Higher-Order Functions ---
+
+export const arrayMap = new BuiltinFunction("map",
+    (args, interpreter, callNode) => {
+        const [arr, callbackFn] = args;
+        expectArray(arr, "map", interpreter, callNode, 1);
+        expectMimoFunction(callbackFn, "map", interpreter, callNode, 2);
+
+        const result = [];
+        for (let i = 0; i < arr.length; i++) {
+            // Call the Mimo callback function: callbackFn(item, index, array)
+            const fullArgs = [arr[i], i, arr];
+            // Only pass as many args as the function declares
+            const callArgs = fullArgs.slice(0, callbackFn.declaration.params.length);
+            const mappedValue = callbackFn.call(interpreter, callArgs);
+            result.push(mappedValue);
+        }
+        return result;
+    },
+    2 // array, callbackFunction
+);
+
+export const arrayFilter = new BuiltinFunction("filter",
+    (args, interpreter, callNode) => {
+        const [arr, callbackFn] = args;
+        expectArray(arr, "filter", interpreter, callNode, 1);
+        expectMimoFunction(callbackFn, "filter", interpreter, callNode, 2);
+
+        const result = [];
+        for (let i = 0; i < arr.length; i++) {
+            // Call the Mimo callback function: callbackFn(item, index, array)
+            const fullArgs = [arr[i], i, arr];
+            // Only pass as many args as the function declares
+            const callArgs = fullArgs.slice(0, callbackFn.declaration.params.length);
+            const shouldInclude = callbackFn.call(interpreter, callArgs);
+            
+            // Use the interpreter's truthy logic
+            if (interpreter.expressionEvaluator.isTruthy(shouldInclude)) {
+                result.push(arr[i]);
+            }
+        }
+        return result;
+    },
+    2 // array, callbackFunction
+);
+
+export const arrayReduce = new BuiltinFunction("reduce",
+    (args, interpreter, callNode) => {
+        const [arr, callbackFn, initialValue] = args;
+        expectArray(arr, "reduce", interpreter, callNode, 1);
+        expectMimoFunction(callbackFn, "reduce", interpreter, callNode, 2);
+
+        if (arr.length === 0 && initialValue === undefined) {
+            throw interpreter.errorHandler.createRuntimeError(
+                `reduce() of empty array with no initial value.`,
+                callNode,
+                'ARG001',
+                `Provide an initial value to reduce() when operating on an empty array.`
+            );
+        }
+
+        let accumulator = initialValue;
+        let startIndex = 0;
+
+        if (initialValue === undefined) {
+            accumulator = arr[0];
+            startIndex = 1;
+        }
+
+        for (let i = startIndex; i < arr.length; i++) {
+            // Call the Mimo callback function: callbackFn(accumulator, currentValue, index, array)
+            const fullArgs = [accumulator, arr[i], i, arr];
+            const callArgs = fullArgs.slice(0, callbackFn.declaration.params.length);
+            accumulator = callbackFn.call(interpreter, callArgs);
+        }
+
+        return accumulator;
+    },
+    [2, 3] // array, callbackFunction, [initialValue]
+);
+
+export const arrayForEach = new BuiltinFunction("for_each",
+    (args, interpreter, callNode) => {
+        const [arr, callbackFn] = args;
+        expectArray(arr, "for_each", interpreter, callNode, 1);
+        expectMimoFunction(callbackFn, "for_each", interpreter, callNode, 2);
+
+        for (let i = 0; i < arr.length; i++) {
+            const fullArgs = [arr[i], i, arr];
+            const callArgs = fullArgs.slice(0, callbackFn.declaration.params.length);
+            callbackFn.call(interpreter, callArgs);
+        }
+
+        return null; // for_each returns null/undefined
+    },
+    2 // array, callbackFunction
+);
+
+export const arrayFind = new BuiltinFunction("find",
+    (args, interpreter, callNode) => {
+        const [arr, callbackFn] = args;
+        expectArray(arr, "find", interpreter, callNode, 1);
+        expectMimoFunction(callbackFn, "find", interpreter, callNode, 2);
+
+        for (let i = 0; i < arr.length; i++) {
+            const fullArgs = [arr[i], i, arr];
+            const callArgs = fullArgs.slice(0, callbackFn.declaration.params.length);
+            const isMatch = callbackFn.call(interpreter, callArgs);
+            if (interpreter.expressionEvaluator.isTruthy(isMatch)) {
+                return arr[i];
+            }
+        }
+
+        return null; // Not found
+    },
+    2 // array, callbackFunction
+);
+
+export const arrayFindIndex = new BuiltinFunction("find_index",
+    (args, interpreter, callNode) => {
+        const [arr, callbackFn] = args;
+        expectArray(arr, "find_index", interpreter, callNode, 1);
+        expectMimoFunction(callbackFn, "find_index", interpreter, callNode, 2);
+
+        for (let i = 0; i < arr.length; i++) {
+            const fullArgs = [arr[i], i, arr];
+            const callArgs = fullArgs.slice(0, callbackFn.declaration.params.length);
+            const isMatch = callbackFn.call(interpreter, callArgs);
+            if (interpreter.expressionEvaluator.isTruthy(isMatch)) {
+                return i;
+            }
+        }
+
+        return -1; // Not found
+    },
+    2 // array, callbackFunction
+);
+
+export const arrayFlat = new BuiltinFunction("flat",
+    (args, interpreter, callNode) => {
+        const [arr, depthArg] = args;
+        expectArray(arr, "flat", interpreter, callNode, 1);
+        const depth = depthArg === undefined ? 1 : depthArg;
+        if (typeof depth !== "number" || !Number.isInteger(depth) || depth < 0) {
+            throw interpreter.errorHandler.createRuntimeError(
+                "flat() depth must be a non-negative integer.",
+                callNode,
+                "TYPE001",
+                "Provide a non-negative integer for flat depth."
+            );
+        }
+
+        const flatten = (input, currentDepth) => {
+            if (currentDepth === 0) return [...input];
+            const result = [];
+            for (const item of input) {
+                if (Array.isArray(item)) {
+                    result.push(...flatten(item, currentDepth - 1));
+                } else {
+                    result.push(item);
+                }
+            }
+            return result;
+        };
+
+        return flatten(arr, depth);
+    },
+    [1, 2]
+);
+
+export const arrayFlatMap = new BuiltinFunction("flat_map",
+    (args, interpreter, callNode) => {
+        const [arr, callbackFn] = args;
+        expectArray(arr, "flat_map", interpreter, callNode, 1);
+        expectMimoFunction(callbackFn, "flat_map", interpreter, callNode, 2);
+
+        const result = [];
+        for (let i = 0; i < arr.length; i++) {
+            const fullArgs = [arr[i], i, arr];
+            const callArgs = fullArgs.slice(0, callbackFn.declaration.params.length);
+            const mapped = callbackFn.call(interpreter, callArgs);
+            if (Array.isArray(mapped)) {
+                result.push(...mapped);
+            } else {
+                result.push(mapped);
+            }
+        }
+        return result;
+    },
+    2
+);
+
+export const arrayGroupBy = new BuiltinFunction("group_by",
+    (args, interpreter, callNode) => {
+        const [arr, callbackFn] = args;
+        expectArray(arr, "group_by", interpreter, callNode, 1);
+        expectMimoFunction(callbackFn, "group_by", interpreter, callNode, 2);
+
+        const groups = {};
+        for (let i = 0; i < arr.length; i++) {
+            const fullArgs = [arr[i], i, arr];
+            const callArgs = fullArgs.slice(0, callbackFn.declaration.params.length);
+            const keyValue = callbackFn.call(interpreter, callArgs);
+            const key = String(keyValue);
+            if (!Object.prototype.hasOwnProperty.call(groups, key)) {
+                groups[key] = [];
+            }
+            groups[key].push(arr[i]);
+        }
+        return groups;
+    },
+    2
+);
+
+export const arrayCount = new BuiltinFunction("count",
+    (args, interpreter, callNode) => {
+        const [arr, callbackFn] = args;
+        expectArray(arr, "count", interpreter, callNode, 1);
+
+        if (callbackFn === undefined) {
+            return arr.length;
+        }
+        expectMimoFunction(callbackFn, "count", interpreter, callNode, 2);
+
+        let matched = 0;
+        for (let i = 0; i < arr.length; i++) {
+            const fullArgs = [arr[i], i, arr];
+            const callArgs = fullArgs.slice(0, callbackFn.declaration.params.length);
+            const keep = callbackFn.call(interpreter, callArgs);
+            if (interpreter.expressionEvaluator.isTruthy(keep)) {
+                matched++;
+            }
+        }
+        return matched;
+    },
+    [1, 2]
+);
+
+export const arrayZip = new BuiltinFunction("zip",
+    (args, interpreter, callNode) => {
+        if (args.length < 2) {
+            throw interpreter.errorHandler.createRuntimeError(
+                "zip() expects at least 2 arrays.",
+                callNode,
+                "BUILTIN001",
+                "Provide at least two arrays to zip()."
+            );
+        }
+
+        args.forEach((arg, index) => expectArray(arg, "zip", interpreter, callNode, index + 1));
+
+        const minLen = Math.min(...args.map((a) => a.length));
+        const zipped = [];
+        for (let i = 0; i < minLen; i++) {
+            zipped.push(args.map((a) => a[i]));
+        }
+        return zipped;
+    },
+    [2, Infinity]
+);
+
+export const arrayChunk = new BuiltinFunction("chunk",
+    (args, interpreter, callNode) => {
+        const [arr, size] = args;
+        expectArray(arr, "chunk", interpreter, callNode, 1);
+        if (typeof size !== "number" || !Number.isInteger(size) || size <= 0) {
+            throw interpreter.errorHandler.createRuntimeError(
+                "chunk() size must be a positive integer.",
+                callNode,
+                "TYPE001",
+                "Provide a positive integer as chunk size."
+            );
+        }
+
+        const chunks = [];
+        for (let i = 0; i < arr.length; i += size) {
+            chunks.push(arr.slice(i, i + size));
+        }
+        return chunks;
+    },
+    2
+);