yukigo 0.2.2 → 0.3.1

package/dist/interpreter/components/EnvBuilder.js

@@ -1,7 +1,24 @@
-import { isRuntimePredicate, TraverseVisitor, } from "yukigo-ast";
-import { InterpreterVisitor } from "./Visitor.js";
-import { idContinuation, trampoline } from "../trampoline.js";
-import { InterpreterError } from "../errors.js";
+import { TraverseVisitor, NamedArgument, } from "yukigo-ast";
+import { InterpreterError, UnexpectedNode } from "../errors.js";
+import { YukigoKernel } from "./kernel/index.js";
+import { EvalCommand } from "./kernel/commands.js";
+import { RuntimeFunction, RuntimeClass, RuntimeObject, isRuntimePredicate, RuntimePredicate, } from "../primitives/index.js";
+import { InterpreterVisitor } from "./evaluators/index.js";
+class NotValidPredicate extends InterpreterError {
+    constructor(identifier) {
+        super("[EnvBuilder]", `"${identifier}" is not a predicate. Maybe there is something else defined as "${identifier}"?`);
+    }
+}
+class FunctionWithNoEquations extends InterpreterError {
+    constructor(identifier) {
+        super("[EnvBuilder]", `Function ${identifier} has no equations`);
+    }
+}
+class FunctionArityMismatch extends InterpreterError {
+    constructor(identifier) {
+        super("[EnvBuilder]", `All equations of ${identifier} must have the same arity`);
+    }
+}
 /**
  * Builds the initial environment by collecting all top-level function declarations.
  * Each function captures a closure of the environment at its definition time,
@@ -9,14 +26,24 @@ import { InterpreterError } from "../errors.js";
  */
 export class EnvBuilderVisitor extends TraverseVisitor {
     ctx;
+    deferredInitializations = [];
     constructor(ctx) {
         super();
         this.ctx = ctx;
     }
     build(ast) {
+        this.declareGlobalSymbols(ast);
+        this.initializeGlobalStates();
+    }
+    declareGlobalSymbols(ast) {
         for (const node of ast)
             node.accept(this);
     }
+    initializeGlobalStates() {
+        for (const initialization of this.deferredInitializations) {
+            initialization.execute(this.ctx);
+        }
+    }
     visitSequence(node) {
         for (const stmt of node.statements)
             stmt.accept(this);
@@ -26,24 +53,18 @@ export class EnvBuilderVisitor extends TraverseVisitor {
         if (this.ctx.config.debug)
             console.log(`[EnvBuilder] Defining function: ${name}`);
         if (node.equations.length === 0)
-            throw new Error(`Function ${name} has no equations`);
+            throw new FunctionWithNoEquations(name);
         const arity = node.equations[0].patterns.length;
         if (node.equations.some((eq) => eq.patterns.length !== arity))
-            throw new Error(`All equations of ${name} must have the same arity`);
-        let placeholder;
-        this.ctx.define(name, placeholder);
+            throw new FunctionArityMismatch(name);
+        let placeholder = new RuntimeFunction(0, []);
+        this.ctx.defineGlobal(name, placeholder);
         const equations = node.equations.map((eq) => ({
             patterns: eq.patterns,
             body: eq.body,
         }));
-        const runtimeFunc = {
-            type: "Function",
-            identifier: name,
-            arity,
-            equations,
-            closure: this.ctx.env,
-        };
-        this.ctx.define(name, runtimeFunc);
+        const runtimeFunc = new RuntimeFunction(arity, equations, name, undefined, this.ctx.env);
+        this.ctx.defineGlobal(name, runtimeFunc);
     }
     visitClass(node) {
         const identifier = node.identifier.value;
@@ -51,98 +72,222 @@ export class EnvBuilderVisitor extends TraverseVisitor {
             console.log(`[EnvBuilder] Defining class: ${identifier}`);
         const superclass = node.extendsSymbol?.value;
         const mixins = node.includes.map((symbol) => symbol.value);
-        const collector = new OOPCollector();
+        const collector = new OOPCollector(this.ctx);
         node.expression.accept(collector);
         const fields = collector.collectedFields;
         const methods = collector.collectedMethods;
-        const runtimeClass = {
-            type: "Class",
-            identifier,
-            fields,
-            methods,
-            superclass,
-            mixins,
-        };
-        this.ctx.define(identifier, runtimeClass);
+        const runtimeClass = new RuntimeClass(identifier, fields, methods, mixins, superclass, collector.fieldInitializers);
+        this.ctx.defineGlobal(identifier, runtimeClass);
     }
     visitObject(node) {
         const identifier = node.identifier.value;
         if (this.ctx.config.debug)
             console.log(`[EnvBuilder] Defining object: ${identifier}`);
-        const collector = new OOPCollector();
+        const collector = new OOPCollector(this.ctx);
         node.expression.accept(collector);
-        const fields = collector.collectedFields;
+        const fields = this.resolveObjectFields(node, collector);
         const methods = collector.collectedMethods;
-        const runtimeObject = {
-            type: "Object",
-            identifier,
-            className: "",
-            fields,
-            methods,
-        };
-        this.ctx.define(identifier, runtimeObject);
+        const runtimeObject = new RuntimeObject(identifier, node.extendsSymbol?.value || "", fields, methods);
+        // Encolamos de forma declarativa la inicialización tardía delegando la tarea
+        const initializers = this.collectAllInitializers(node, collector);
+        this.deferredInitializations.push(new DeferredInitialization(runtimeObject, initializers));
+        this.ctx.defineGlobal(identifier, runtimeObject);
+    }
+    resolveObjectFields(node, collector) {
+        const fields = collector.collectedFields;
+        const extendsSymbol = node.extendsSymbol?.value;
+        if (extendsSymbol) {
+            const classDef = this.ctx.lookup(extendsSymbol);
+            if (classDef && classDef instanceof RuntimeClass) {
+                const inheritedFields = this.getClassFields(classDef);
+                for (const [k, v] of inheritedFields.entries()) {
+                    if (!fields.has(k))
+                        fields.set(k, v);
+                }
+            }
+        }
+        return fields;
+    }
+    collectAllInitializers(node, collector) {
+        const initializers = new Map();
+        const extendsSymbol = node.extendsSymbol?.value;
+        // 1. Heredados de la Clase Madre
+        if (extendsSymbol) {
+            const classDef = this.ctx.lookup(extendsSymbol);
+            if (classDef && classDef instanceof RuntimeClass) {
+                for (const [k, expr] of this.getClassInitializers(classDef).entries()) {
+                    initializers.set(k, expr);
+                }
+            }
+        }
+        // 2. Definiciones locales del propio Objeto
+        for (const [k, expr] of collector.fieldInitializers.entries()) {
+            initializers.set(k, expr);
+        }
+        // 3. Argumentos nombrados por constructor inline
+        const extendsArgs = node.extendsArgs || [];
+        for (const arg of extendsArgs) {
+            if (arg instanceof NamedArgument ||
+                arg.constructor.name === "NamedArgument") {
+                initializers.set(arg.identifier.value, arg.expression);
+            }
+        }
+        return initializers;
     }
     visitFact(node) {
         const identifier = node.identifier.value;
         if (this.ctx.config.debug)
             console.log(`[EnvBuilder] Defining fact: ${identifier}`);
-        try {
+        if (this.ctx.isDefined(identifier)) {
             const runtimeValue = this.ctx.lookup(identifier);
             if (!isRuntimePredicate(runtimeValue))
-                throw new InterpreterError("EnvBuilder", `"${identifier}" is not a predicate. Maybe there is something else defined as "${identifier}"?`);
-            runtimeValue.equations.push(node);
+                throw new NotValidPredicate(identifier);
+            runtimeValue.addClause(node);
         }
-        catch (error) {
-            this.ctx.define(identifier, {
-                kind: "Predicate",
-                identifier,
-                equations: [node],
-            });
+        else {
+            const predicate = new RuntimePredicate(identifier, [node]);
+            this.ctx.defineGlobal(identifier, predicate);
         }
     }
     visitRule(node) {
         const identifier = node.identifier.value;
         if (this.ctx.config.debug)
             console.log(`[EnvBuilder] Defining rule: ${identifier}`);
-        try {
+        if (this.ctx.isDefined(identifier)) {
             const runtimeValue = this.ctx.lookup(identifier);
             if (!isRuntimePredicate(runtimeValue))
-                throw new InterpreterError("EnvBuilder", `"${identifier}" is not a predicate. Maybe there is something else defined as "${identifier}"?`);
-            runtimeValue.equations.push(node);
+                throw new NotValidPredicate(identifier);
+            runtimeValue.addClause(node);
         }
-        catch (error) {
-            this.ctx.define(identifier, {
-                kind: "Predicate",
-                identifier,
-                equations: [node],
-            });
+        else {
+            const predicate = new RuntimePredicate(identifier, [node]);
+            this.ctx.defineGlobal(identifier, predicate);
         }
     }
+    getClassFields(classDef) {
+        const fields = new Map();
+        const collect = (c) => {
+            if (c.superclass) {
+                const superDef = this.ctx.lookup(c.superclass);
+                if (superDef && superDef instanceof RuntimeClass) {
+                    collect(superDef);
+                }
+            }
+            for (const mixin of c.mixins) {
+                const mixinDef = this.ctx.lookup(mixin);
+                if (mixinDef && mixinDef instanceof RuntimeClass) {
+                    collect(mixinDef);
+                }
+            }
+            for (const [k, v] of c.fields.entries()) {
+                fields.set(k, v);
+            }
+        };
+        collect(classDef);
+        return fields;
+    }
+    getClassInitializers(classDef) {
+        const initializers = new Map();
+        const collect = (c) => {
+            if (c.superclass) {
+                const superDef = this.ctx.lookup(c.superclass);
+                if (superDef && superDef instanceof RuntimeClass) {
+                    collect(superDef);
+                }
+            }
+            for (const mixin of c.mixins) {
+                const mixinDef = this.ctx.lookup(mixin);
+                if (mixinDef && mixinDef instanceof RuntimeClass) {
+                    collect(mixinDef);
+                }
+            }
+            const cInitializers = c.fieldInitializers;
+            if (cInitializers) {
+                for (const [k, v] of cInitializers.entries()) {
+                    initializers.set(k, v);
+                }
+            }
+        };
+        collect(classDef);
+        return initializers;
+    }
     visitVariable(node) {
         const identifier = node.identifier.value;
         if (this.ctx.config.debug)
             console.log(`[EnvBuilder] Defining variable: ${identifier}`);
-        const interpreter = new InterpreterVisitor(this.ctx);
-        const cps = node.expression.accept(interpreter);
-        this.ctx.define(identifier, trampoline(cps(idContinuation)));
+        const visitor = new InterpreterVisitor(this.ctx);
+        const kernel = new YukigoKernel(visitor);
+        this.ctx.defineGlobal(identifier, kernel.run(new EvalCommand(node.expression)));
     }
     visit(node) {
         return node.accept(this);
     }
+    fallback(node) {
+        throw new UnexpectedNode(node.constructor.name, "EnvBuilderVisitor");
+    }
 }
-class OOPCollector extends TraverseVisitor {
+class DeferredInitialization {
+    runtimeObject;
+    initializers;
+    constructor(runtimeObject, initializers) {
+        this.runtimeObject = runtimeObject;
+        this.initializers = initializers;
+    }
+    execute(ctx) {
+        for (const [fieldName, expression] of this.initializers.entries()) {
+            this.initializeField(fieldName, expression, ctx);
+        }
+    }
+    initializeField(fieldName, expr, ctx) {
+        try {
+            const rawResult = InterpreterVisitor.evaluateLiteral(expr, ctx);
+            const evaluatedValue = this.resolveExecutionValue(rawResult, ctx);
+            this.runtimeObject.setField(fieldName, evaluatedValue);
+        }
+        catch (error) {
+            this.logWarning(fieldName, error, ctx);
+        }
+    }
+    resolveExecutionValue(rawResult, ctx) {
+        // Si el resultado requiere ejecución diferida en el Kernel de Yukigo, lo resolvemos de forma atómica
+        if (rawResult && typeof rawResult.execute === "function") {
+            const visitor = new InterpreterVisitor(ctx);
+            const uniqueKernel = new YukigoKernel(visitor, "first");
+            return uniqueKernel.run(rawResult);
+        }
+        return rawResult;
+    }
+    logWarning(fieldName, error, ctx) {
+        if (ctx.config.debug) {
+            console.log(`[EnvBuilder] [Warning Tardío] No se pudo evaluar el atributo ${fieldName} en '${this.runtimeObject.identifier}':`, error);
+        }
+    }
+}
+export class OOPCollector extends TraverseVisitor {
+    ctx;
     collectedMethods = new Map();
     collectedFields = new Map();
+    fieldInitializers = new Map();
+    constructor(ctx) {
+        super();
+        this.ctx = ctx;
+    }
     visitMethod(node) {
-        const runtimeMethod = {
-            type: "Function",
-            identifier: node.identifier.value,
-            arity: node.equations[0].patterns.length,
-            equations: node.equations,
-        };
-        this.collectedMethods.set(node.identifier.value, runtimeMethod);
+        const name = node.identifier.value;
+        const arity = node.equations[0].patterns.length;
+        const key = `${name}/${arity}`;
+        const runtimeMethod = new RuntimeFunction(arity, [...node.equations], name);
+        this.collectedMethods.set(key, runtimeMethod);
     }
     visitAttribute(node) {
-        this.collectedFields.set(node.identifier.value, InterpreterVisitor.evaluateLiteral(node.expression));
+        const fieldName = node.identifier.value;
+        // Registramos la expresión diferida
+        this.fieldInitializers.set(fieldName, node.expression);
+        // Inicializamos transitoriamente el campo con YuNil para reservar su espacio en la firma
+        const initialPlaceholder = global.YuNil?.getInstance() || null;
+        this.collectedFields.set(fieldName, initialPlaceholder);
+    }
+    fallback(node) {
+        throw new UnexpectedNode(node.constructor.name, "OOPCollector");
     }
 }

package/dist/interpreter/components/EqualityComparer.d.ts

@@ -0,0 +1,15 @@
+import { YuValue } from "../primitives/YuValue.js";
+import { ExecutionCommand } from "./kernel/commands.js";
+import { RuntimeContext } from "./RuntimeContext.js";
+/**
+ * Utility to perform deep equality checks between YuValues,
+ * including lazy sequences, using polymorphic capabilities.
+ */
+export declare class EqualityComparer {
+    /**
+     * Performs a deep equality check between two values.
+     * If both are sequences, they are compared element by element lazily.
+     */
+    static compare(a: YuValue, b: YuValue, ctx?: RuntimeContext): ExecutionCommand;
+    private static compareSequences;
+}

package/dist/interpreter/components/EqualityComparer.js

@@ -0,0 +1,69 @@
+import { boolean, isTrue } from "../utils.js";
+import { BindCommand, } from "./kernel/commands.js";
+import { RuntimeFunction } from "../primitives/entities/RuntimeFunction.js";
+/**
+ * Utility to perform deep equality checks between YuValues,
+ * including lazy sequences, using polymorphic capabilities.
+ */
+export class EqualityComparer {
+    /**
+     * Performs a deep equality check between two values.
+     * If both are sequences, they are compared element by element lazily.
+     */
+    static compare(a, b, ctx) {
+        if (ctx &&
+            a instanceof RuntimeFunction &&
+            a.arity === 0 &&
+            (a.pendingArgs?.length ?? 0) === 0) {
+            return new BindCommand(ctx.forceValue(a), (forcedA) => this.compare(forcedA, b, ctx));
+        }
+        if (ctx &&
+            b instanceof RuntimeFunction &&
+            b.arity === 0 &&
+            (b.pendingArgs?.length ?? 0) === 0) {
+            return new BindCommand(ctx.forceValue(b), (forcedB) => this.compare(a, forcedB, ctx));
+        }
+        const seqA = a.asSequence;
+        const seqB = b.asSequence;
+        if (seqA && seqB) {
+            return this.compareSequences(seqA, seqB, ctx);
+        }
+        const compA = a.asComparable;
+        if (compA)
+            return compA.equals(b);
+        return boolean(a === b);
+    }
+    static compareSequences(sA, sB, ctx) {
+        if (!sA && !sB)
+            return boolean(true);
+        // If one is null, the other must be empty to be equal
+        if (!sA) {
+            return new BindCommand(sB.step(), (resB) => boolean(resB.isNil));
+        }
+        if (!sB) {
+            return new BindCommand(sA.step(), (resA) => boolean(resA.isNil));
+        }
+        return new BindCommand(sA.step(), (resA) => {
+            return new BindCommand(sB.step(), (resB) => {
+                // Use polymorphism (isNil) instead of instanceof YuNil
+                if (resA.isNil && resB.isNil)
+                    return boolean(true);
+                if (resA.isNil || resB.isNil)
+                    return boolean(false);
+                // Use polymorphism (asStepResult) instead of instanceof LazyStepResult
+                const stepResA = resA.asStepResult;
+                const stepResB = resB.asStepResult;
+                if (!stepResA || !stepResB)
+                    return boolean(false);
+                // Compare heads recursively
+                return new BindCommand(this.compare(stepResA.head, stepResB.head, ctx), (headsEqual) => {
+                    const areHeadsEqual = isTrue(headsEqual);
+                    if (!areHeadsEqual)
+                        return boolean(false);
+                    // Compare tails
+                    return this.compareSequences(stepResA.tail, stepResB.tail, ctx);
+                });
+            });
+        });
+    }
+}

package/dist/interpreter/components/Operations.d.ts

@@ -1,14 +1,17 @@
-import { PrimitiveValue } from "yukigo-ast";
-export type UnaryOp<T, R = T> = (x: T) => R;
-export type BinaryOp<T, R = T> = (x: T, y: T) => R;
-export type OperatorTable<T> = Record<string, T>;
-export declare const ArithmeticBinaryTable: OperatorTable<BinaryOp<number>>;
-export declare const ComparisonOperationTable: OperatorTable<BinaryOp<boolean>>;
-export declare const LogicalBinaryTable: OperatorTable<(l: boolean, r: () => boolean) => boolean>;
-export declare const BitwiseBinaryTable: OperatorTable<BinaryOp<number>>;
-export declare const StringOperationTable: OperatorTable<BinaryOp<any, string>>;
-export declare const BitwiseUnaryTable: OperatorTable<UnaryOp<number>>;
-export declare const LogicalUnaryTable: OperatorTable<UnaryOp<boolean>>;
-export declare const ListBinaryTable: OperatorTable<BinaryOp<any, PrimitiveValue>>;
-export declare const ListUnaryTable: OperatorTable<UnaryOp<PrimitiveValue[], PrimitiveValue>>;
-export declare const ArithmeticUnaryTable: OperatorTable<UnaryOp<number, number | string>>;
+import { YuNumeric, YuComparable, YuLogic, YuSummable, YuSequence } from "../primitives/capabilities.js";
+import { YuValue } from "../primitives/index.js";
+import { ExecutionCommand } from "./kernel/commands.js";
+export type UnaryOp<T extends YuValue> = (x: T) => ExecutionCommand;
+export type BinaryOp<T1 extends YuValue, T2 = T1> = (x: T1, y: T2) => ExecutionCommand;
+export type BinaryTable<T1 extends YuValue, T2 = T1> = Record<string, BinaryOp<T1, T2>>;
+export type UnaryTable<T extends YuValue> = Record<string, UnaryOp<T>>;
+export declare const ArithmeticBinaryTable: BinaryTable<YuNumeric>;
+export declare const ComparisonOperationTable: BinaryTable<YuComparable>;
+export declare const LogicalBinaryTable: BinaryTable<YuLogic, () => ExecutionCommand>;
+export declare const StringOperationTable: BinaryTable<YuSummable>;
+export declare const BitwiseBinaryTable: BinaryTable<YuNumeric>;
+export declare const BitwiseUnaryTable: UnaryTable<YuNumeric>;
+export declare const LogicalUnaryTable: UnaryTable<YuLogic>;
+export declare const ListBinaryTable: BinaryTable<YuSequence>;
+export declare const ListUnaryTable: UnaryTable<YuSequence>;
+export declare const ArithmeticUnaryTable: UnaryTable<YuNumeric>;

package/dist/interpreter/components/Operations.js

@@ -1,84 +1,83 @@
-import { isArrayOfNumbers } from "../utils.js";
+import { InterpreterError } from "../errors.js";
+import { YuNumber, YuArray, YuString } from "../primitives/index.js";
+import { compareResult, not, number } from "../utils.js";
+import { RaiseCommand, StepCommand, } from "./kernel/commands.js";
 export const ArithmeticBinaryTable = {
-    Plus: (a, b) => a + b,
-    Minus: (a, b) => a - b,
-    Multiply: (a, b) => a * b,
-    Divide: (a, b) => a / b,
-    Modulo: (a, b) => a % b,
-    Power: (a, b) => a ** b,
-    Min: (a, b) => Math.min(a, b),
-    Max: (a, b) => Math.max(a, b),
+    Plus: (a, b) => a.plus(b),
+    Minus: (a, b) => a.minus(b),
+    Multiply: (a, b) => a.multiply(b),
+    Divide: (a, b) => a.divide(b),
+    Modulo: (a, b) => a.modulo(b),
+    Power: (a, b) => a.power(b),
+    Min: (a, b) => a.min(b),
+    Max: (a, b) => a.max(b),
 };
 export const ComparisonOperationTable = {
-    Equal: (a, b) => a == b,
-    NotEqual: (a, b) => a != b,
-    Same: (a, b) => a === b,
-    NotSame: (a, b) => a !== b,
-    //Similar: (a, b) => ,
-    //NotSimilar: (a, b) => ,
-    GreaterOrEqualThan: (a, b) => a >= b,
-    GreaterThan: (a, b) => a > b,
-    LessOrEqualThan: (a, b) => a <= b,
-    LessThan: (a, b) => a < b,
+    Equal: (a, b) => a.equals(b),
+    NotEqual: (a, b) => not(a.equals(b)),
+    Same: (a, b) => a.isSame(b),
+    NotSame: (a, b) => not(a.isSame(b)),
+    GreaterOrEqualThan: (a, b) => compareResult(a.compare(b), (res) => res >= 0),
+    GreaterThan: (a, b) => compareResult(a.compare(b), (res) => res > 0),
+    LessOrEqualThan: (a, b) => compareResult(a.compare(b), (res) => res <= 0),
+    LessThan: (a, b) => compareResult(a.compare(b), (res) => res < 0),
 };
 export const LogicalBinaryTable = {
-    And: (left, rightThunk) => left && rightThunk(),
-    Or: (left, rightThunk) => left || rightThunk(),
-};
-export const BitwiseBinaryTable = {
-    BitwiseOr: (a, b) => a | b,
-    BitwiseAnd: (a, b) => a & b,
-    BitwiseLeftShift: (a, b) => a << b,
-    BitwiseRightShift: (a, b) => a >> b,
-    BitwiseUnsignedRightShift: (a, b) => a >>> b,
-    BitwiseXor: (a, b) => a ^ b,
+    And: (left, rightThunk) => left.value ? rightThunk() : new StepCommand(left),
+    Or: (left, rightThunk) => left.value ? new StepCommand(left) : rightThunk(),
 };
 export const StringOperationTable = {
-    Concat: (a, b) => {
-        if ((typeof a !== "string" && typeof a !== "number") ||
-            (typeof b !== "string" && typeof b !== "number")) {
-            throw new Error(`String Concatenation: operands must be strings or numbers, got ${typeof a} and ${typeof b}`);
-        }
-        return String(a) + String(b);
-    },
+    Concat: (a, b) => a.plus(b),
+};
+export const BitwiseBinaryTable = {
+    BitwiseOr: (a, b) => new StepCommand(new YuNumber(a.value | b.value)),
+    BitwiseAnd: (a, b) => new StepCommand(new YuNumber(a.value & b.value)),
+    BitwiseLeftShift: (a, b) => new StepCommand(new YuNumber(a.value << b.value)),
+    BitwiseRightShift: (a, b) => new StepCommand(new YuNumber(a.value >> b.value)),
+    BitwiseUnsignedRightShift: (a, b) => new StepCommand(new YuNumber(a.value >>> b.value)),
+    BitwiseXor: (a, b) => new StepCommand(new YuNumber(a.value ^ b.value)),
 };
 export const BitwiseUnaryTable = {
-    BitwiseNot: (a) => ~a,
+    BitwiseNot: (a) => number(~a.value),
 };
 export const LogicalUnaryTable = {
-    Negation: (a) => !a,
+    Negation: (a) => a.not(),
 };
 export const ListBinaryTable = {
-    Concat: (a, b) => {
-        const res = a.concat(b);
-        if (typeof a === "string" && typeof b === "string") {
-            const hasNonString = res.some((c) => typeof c !== "string");
-            if (!hasNonString)
-                return res.join("");
-        }
-        return res;
-    },
+    Concat: (a, b) => a.concat(b),
 };
 export const ListUnaryTable = {
-    Size: (a) => a.length,
+    Size: (a) => a.size(),
     DetectMax: (a) => {
-        if (!isArrayOfNumbers(a))
-            throw new Error("Operand of DetectMax must be Array of numbers");
-        return Math.max(...a);
+        const items = [...a].map((i) => {
+            const n = i.toJSON();
+            return n;
+        });
+        if (items.some((n) => typeof n !== "number"))
+            return new RaiseCommand(new InterpreterError("DetectMax", "elements must be numbers")); // TODO: make it work with chars, etc.
+        return number(Math.max(...items));
     },
     DetectMin: (a) => {
-        if (!isArrayOfNumbers(a))
-            throw new Error("Operand of DetectMin must be Array of numbers");
-        return Math.min(...a);
+        const items = [...a].map((i) => {
+            const n = i.toJSON();
+            return n;
+        });
+        if (items.some((n) => typeof n !== "number"))
+            return new RaiseCommand(new InterpreterError("DetectMin", "elements must be numbers")); // TODO: make it work with chars, etc.
+        return number(Math.min(...items));
+    },
+    Flatten: (a) => {
+        if (!(a instanceof YuArray))
+            return new RaiseCommand(new InterpreterError("[Flat operator]", "Operand must be a YuArray"));
+        return new StepCommand(a.flat());
     },
-    Flatten: (a) => a.flat(),
 };
 export const ArithmeticUnaryTable = {
-    Round: (a) => Math.round(a),
-    Absolute: (a) => Math.abs(a),
-    Ceil: (a) => Math.ceil(a),
-    Floor: (a) => Math.floor(a),
-    Negation: (a) => a * -1,
-    Sqrt: (a) => Math.sqrt(a),
-    ToString: (a) => String(a),
+    Round: (a) => a.round(),
+    Absolute: (a) => a.abs(),
+    Ceil: (a) => a.ceil(),
+    Floor: (a) => a.floor(),
+    Negation: (a) => a.negation(),
+    Sqrt: (a) => a.sqrt(),
+    ToString: (a) => new StepCommand(new YuString(String(a.toJSON()))),
 };