yukigo 0.2.3 → 0.3.2

package/dist/interpreter/components/runtimes/ObjectRuntime.js

@@ -1,99 +1,115 @@
-import { isRuntimeObject, isRuntimeClass, } from "yukigo-ast";
 import { InterpreterError } from "../../errors.js";
+import { isRuntimeObject, YuString, isRuntimeClass, YuBoolean, YuNil, } from "../../primitives/index.js";
+import { error, raise } from "../../utils.js";
+import { BindCommand, StepCommand, RaiseCommand, } from "../kernel/commands.js";
 export class ObjectRuntime {
     context;
     constructor(context) {
         this.context = context;
     }
-    /**
-     * Creates a new instance of an Object.
-     * Typically called by visitNew()
-     */
-    instantiate(className, identifier, fieldDefinitions, methodDefinitions) {
-        return {
-            type: "Object",
-            className,
-            identifier,
-            fields: new Map(fieldDefinitions),
-            methods: methodDefinitions,
-        };
-    }
     /**
      * Handles Method Calls (Message Passing).
      * Reuses FunctionRuntime to execute the method body.
      */
-    dispatch(receiver, methodName, args, env, k) {
-        if (!isRuntimeObject(receiver))
-            throw new Error(`${receiver} is not an object`);
-        const chain = this.getResolutionChain(receiver, env);
-        const match = this.findMethodInChain(chain, methodName);
-        if (!match)
-            throw new InterpreterError("MethodDispatch", `${receiver.className} does not understand '${methodName}'.`);
-        const objectScope = this.createDispatchScope(receiver, match, methodName);
+    dispatch(receiver, methodName, args) {
+        if (!isRuntimeObject(receiver)) {
+            return this.dispatchPrimitive(receiver, methodName, args);
+        }
+        const chain = this.getResolutionChain(receiver);
+        const arity = args.length;
+        const arityKey = `${methodName}/${arity}`;
+        let match = this.findMethodInChain(chain, arityKey);
+        if (!match) {
+            match = this.findMethodInChain(chain, methodName);
+        }
+        if (!match) {
+            if (methodName === "toString") {
+                return new StepCommand(new YuString(receiver.toString()));
+            }
+            if (methodName === "error") {
+                const errorMsg = args[0] ? args[0].toString() : "An error occurred";
+                return new RaiseCommand(new InterpreterError("Raise", errorMsg));
+            }
+            return raise(error("MethodDispatch", `${receiver.className} does not understand '${methodName}'.`));
+        }
+        const objectScope = receiver.createDispatchScope(match, new YuString(methodName));
         this.context.pushEnv(objectScope);
-        return this.context.funcRuntime.apply(match.method, args, k);
+        return new BindCommand(this.context.funcRuntime.apply(match.method, args), (res) => {
+            this.context.popEnv();
+            return new StepCommand(res);
+        });
     }
     /**
      * Handles calls to super() or super.method()
      */
-    dispatchSuper(currentEnv, methodName, args, k) {
+    dispatchSuper(methodName, args) {
         const self = this.context.lookup("self");
         const currentHolder = this.context.lookup("__CONTEXT_CLASS__");
         const currentMethodName = this.context.lookup("__METHOD_NAME__");
-        const targetMethodName = methodName || currentMethodName;
         if (!self || !currentHolder)
-            throw new InterpreterError("SuperError", "'super' used outside of a method context");
-        const chain = this.getResolutionChain(self, currentEnv);
+            return raise(error("dispatchSuper", "'super' used outside of a method context"));
+        const chain = this.getResolutionChain(self);
         const currentIndex = chain.findIndex((c) => c === currentHolder);
         if (currentIndex === -1)
-            throw new Error("Fatal: Execution context not found in hierarchy chain");
+            return raise(error("dispatchSuper", "Execution context not found in hierarchy chain"));
         const remainingChain = chain.slice(currentIndex + 1);
-        const match = this.findMethodInChain(remainingChain, methodName);
+        const baseName = methodName || currentMethodName.toJSON();
+        const arityKey = `${baseName}/${args.length}`;
+        let match = this.findMethodInChain(remainingChain, arityKey);
+        // Fallback: si no encuentra con aridad, buscar solo por nombre (para compatibilidad)
+        if (!match && methodName) {
+            match = this.findMethodInChain(remainingChain, methodName);
+        }
+        if (!match && !methodName) {
+            match = this.findMethodInChain(remainingChain, currentMethodName.toJSON());
+        }
         if (!match)
-            throw new InterpreterError("Super", `Super method '${methodName}' not found`);
-        const objectScope = this.createDispatchScope(self, match, targetMethodName);
+            return raise(error("Super", `Super method '${baseName}' not found`));
+        const objectScope = self.createDispatchScope(match, new YuString(baseName));
         this.context.pushEnv(objectScope);
-        return this.context.funcRuntime.apply(match.method, args, k);
+        return new BindCommand(this.context.funcRuntime.apply(match.method, args), (res) => {
+            this.context.popEnv();
+            return new StepCommand(res);
+        });
     }
-    createDispatchScope(self, match, targetName) {
-        const objectScope = new Map();
-        objectScope.set("self", self);
-        objectScope.set("__CONTEXT_CLASS__", match.holder);
-        objectScope.set("__METHOD_NAME__", targetName);
-        for (const [key, val] of self.fields)
-            objectScope.set(key, val);
-        return objectScope;
+    getResolutionChain(receiver) {
+        const chain = [receiver];
+        if (receiver.className) {
+            const hierarchy = this.expandClassHierarchy(receiver.className);
+            chain.push(...hierarchy);
+        }
+        return chain;
     }
-    getResolutionChain(receiver, env) {
+    expandClassHierarchy(className) {
         const chain = [];
-        chain.push(receiver);
-        if (receiver.className) {
-            this.expandClassHierarchy(receiver.className, env, chain);
+        const visited = new Set();
+        const queue = [className];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            // occurs check to avoid circular loops
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            const classDef = this.getClassDef(current);
+            chain.push(classDef);
+            queue.push(...classDef.getHierarchy());
         }
         return chain;
     }
-    expandClassHierarchy(className, env, chain) {
-        const classDef = this.context.lookup(className);
+    getClassDef(name) {
+        const classDef = this.context.lookup(name);
         if (!isRuntimeClass(classDef))
-            throw new InterpreterError("expandClassHierarchy", "classDef was expected to be a RuntimeClass");
-        chain.push(classDef);
-        const classDefCopy = [...classDef.mixins];
-        if (classDef.mixins)
-            classDefCopy.reverse().forEach((mixinName) => {
-                this.expandClassHierarchy(mixinName, env, chain);
-            });
-        if (classDef.superclass)
-            this.expandClassHierarchy(classDef.superclass, env, chain);
+            throw error("expandClassHierarchy", "classDef was expected to be a RuntimeClass");
+        return classDef;
     }
     findMethodInChain(chain, methodName) {
-        for (const link of chain) {
-            if (link.methods.has(methodName))
-                return {
-                    method: link.methods.get(methodName),
-                    holder: link,
-                };
-        }
-        return undefined;
+        const match = chain.find((def) => def.methods.has(methodName));
+        if (!match)
+            return undefined;
+        return {
+            method: match.methods.get(methodName),
+            holder: match,
+        };
     }
     /**
      * Field Access (Get)
@@ -102,25 +118,40 @@ export class ObjectRuntime {
     getField(receiver, fieldName) {
         if (!isRuntimeObject(receiver))
             throw new InterpreterError("FieldAccess", "Target is not an object");
-        if (!receiver.fields.has(fieldName)) {
-            if (receiver.methods.has(fieldName))
-                return receiver.methods.get(fieldName);
-            throw new InterpreterError("FieldAccess", `Field '${fieldName}' not found in ${receiver.className}`);
-        }
-        return receiver.fields.get(fieldName);
+        if (receiver.hasMethod(fieldName))
+            return receiver.getMethod(fieldName);
+        return receiver.getField(fieldName);
     }
     /**
      * Field Mutation (Set)
      * e.g. self.myField = 10
      */
-    setField(receiver, fieldName, value) {
+    setField(obj, fieldName, value) {
         if (!this.context.config.mutability)
             throw new InterpreterError("FieldAssignment", `Cannot mutate field '${fieldName}': mutability is disabled`);
+        const receiver = this.getReceiver(obj);
         if (!isRuntimeObject(receiver))
             throw new InterpreterError("FieldAssignment", "Target is not an object");
-        if (!receiver.fields.has(fieldName))
-            throw new InterpreterError("FieldAssignment", `Cannot set unknown field '${fieldName}'`);
-        receiver.fields.set(fieldName, value);
-        return value;
+        receiver.setField(fieldName, value);
+        return new YuBoolean(true);
+    }
+    getReceiver(obj) {
+        if (isRuntimeObject(obj) || isRuntimeClass(obj))
+            return obj;
+        throw new InterpreterError("ObjectRuntime", "Receiver is not an OOP entity");
+    }
+    dispatchPrimitive(receiver, methodName, args) {
+        if (!receiver || receiver.isNil)
+            return new StepCommand(YuNil.getInstance());
+        // Obtenemos el identificador polimórfico del tipo (ej: "YuArray", "YuNumber", "YuString", "RuntimeFunction")
+        const typeKey = receiver.constructor.name;
+        const lookupKey = `${typeKey}.${methodName}`;
+        // Buscamos si el ecosistema/lenguaje proveyó una implementación externa para este caso
+        const nativeImpl = this.context.config.nativeProviders.get(lookupKey);
+        if (nativeImpl) {
+            // Delegamos la subtarea de forma declarativa pasándole el receptor como contexto
+            return new BindCommand(nativeImpl(receiver, args, this.context), (res) => new StepCommand(res));
+        }
+        return raise(error("ObjectRuntime.dispatch", `Primitive type '${typeKey}' does not understand method '${methodName}'.`));
     }
 }

package/dist/interpreter/errors.d.ts

@@ -1,4 +1,5 @@
 import { SourceLocation } from "yukigo-ast";
+import { YuValue } from "./primitives/YuValue.js";
 export interface ErrorFrame {
     nodeType: string;
     loc?: SourceLocation;
@@ -11,9 +12,18 @@ export declare class InterpreterError extends Error {
     formatStack(): string;
     toString(): string;
 }
+export declare class UnexpectedNode extends InterpreterError {
+    constructor(nodeCons: string, context: string);
+}
 export declare class UnexpectedValue extends InterpreterError {
     constructor(ctx: string, expected: string, got: string);
 }
 export declare class UnboundVariable extends Error {
     constructor(name: string);
 }
+export declare class NotConcatenable extends InterpreterError {
+    constructor();
+}
+export declare class UnsupportedOperation extends InterpreterError {
+    constructor(val: YuValue, op: string);
+}

package/dist/interpreter/errors.js

@@ -5,6 +5,7 @@ export class InterpreterError extends Error {
         super(`[${context}] ${message}`);
         this.context = context;
         this.frames = frames;
+        this.name = "InterpreterError";
     }
     pushFrame(frame) {
         this.frames.push(frame);
@@ -24,6 +25,12 @@ export class InterpreterError extends Error {
         return `${this.message}${this.formatStack()}`;
     }
 }
+export class UnexpectedNode extends InterpreterError {
+    constructor(nodeCons, context) {
+        super(context, `${nodeCons} not expected in ${context}.`);
+        this.name = "UnexpectedNode";
+    }
+}
 export class UnexpectedValue extends InterpreterError {
     constructor(ctx, expected, got) {
         super(ctx, `Expected ${expected} but got ${got}`);
@@ -34,3 +41,13 @@ export class UnboundVariable extends Error {
         super(`Unbound variable: ${name}`);
     }
 }
+export class NotConcatenable extends InterpreterError {
+    constructor() {
+        super("[Concat]", "Cannot concat non-concatenable types.");
+    }
+}
+export class UnsupportedOperation extends InterpreterError {
+    constructor(val, op) {
+        super("[Unsupported]", `${val.getType()} does not support '${op}'`);
+    }
+}

package/dist/interpreter/index.d.ts

@@ -1,6 +1,9 @@
-import { PrimitiveValue, AST, ASTNode } from "yukigo-ast";
-import { InterpreterConfig } from "./components/RuntimeContext.js";
-export type Bindings = [string, PrimitiveValue][];
+import { AST, ASTNode } from "yukigo-ast";
+import { RuntimeContext } from "./components/RuntimeContext.js";
+import { YuValue } from "./primitives/index.js";
+import { InterpreterConfig } from "../utils/helpers.js";
+export * from "./primitives/index.js";
+export type Bindings = [string, YuValue][];
 /**
  * The Interpreter class is responsible for evaluating the Abstract Syntax Tree (AST)
  * generated by the parsers.
@@ -13,12 +16,13 @@ export declare class Interpreter {
     /**
      * @param ast The Abstract Syntax Tree (AST) of the program to be interpreted.
      */
-    constructor(ast: AST, config?: InterpreterConfig);
+    constructor(ast: AST, config?: Partial<InterpreterConfig>);
     /**
      * Evaluates a single Expression node within the context of the global environment.
      *
      * @param expr The root Expression node to be evaluated.
      * @returns The resulting primitive value (number, string, boolean, etc.) after evaluation.
      */
-    evaluate(expr: ASTNode): PrimitiveValue;
+    evaluate(expr: ASTNode): YuValue;
+    getContext(): RuntimeContext;
 }

package/dist/interpreter/index.js

@@ -1,8 +1,9 @@
-import { InterpreterVisitor } from "./components/Visitor.js";
 import { EnvBuilderVisitor } from "./components/EnvBuilder.js";
-import { InterpreterError } from "./errors.js";
-import { idContinuation, trampoline } from "./trampoline.js";
 import { RuntimeContext, } from "./components/RuntimeContext.js";
+import { YukigoKernel } from "./components/kernel/index.js";
+import { EvalCommand } from "./components/kernel/commands.js";
+import { InterpreterVisitor } from "./components/evaluators/index.js";
+export * from "./primitives/index.js";
 /**
  * The Interpreter class is responsible for evaluating the Abstract Syntax Tree (AST)
  * generated by the parsers.
@@ -27,15 +28,12 @@ export class Interpreter {
      * @returns The resulting primitive value (number, string, boolean, etc.) after evaluation.
      */
     evaluate(expr) {
-        try {
-            const visitor = new InterpreterVisitor(this.context);
-            const evaluatedCPS = expr.accept(visitor);
-            return trampoline(evaluatedCPS(idContinuation));
-        }
-        catch (error) {
-            if (error instanceof InterpreterError)
-                console.log(error.formatStack());
-            throw error;
-        }
+        const visitor = new InterpreterVisitor(this.context);
+        const outputMode = this.context.config.outputMode;
+        const kernel = new YukigoKernel(visitor, outputMode);
+        return kernel.run(new EvalCommand(expr));
+    }
+    getContext() {
+        return this.context;
     }
 }

package/dist/interpreter/primitives/YuValue.d.ts

@@ -0,0 +1,21 @@
+import { ExecutionCommand } from "../components/kernel/commands.js";
+import { YuNumeric, YuSummable, YuSequence, YuLogic, YuComparable, YuStepResult } from "./capabilities.js";
+/**
+ * Base class for all Yukigo values.
+ */
+export declare abstract class YuValue {
+    abstract toString(seen?: Set<YuValue>): string;
+    abstract toJSON(keyOrSeen?: string | Set<YuValue>): unknown;
+    getType(): string;
+    realize(): ExecutionCommand;
+    get asSummable(): YuSummable | undefined;
+    get asNumeric(): YuNumeric | undefined;
+    get asSequence(): YuSequence | undefined;
+    get asLogic(): YuLogic | undefined;
+    get asComparable(): YuComparable | undefined;
+    get asStepResult(): YuStepResult | undefined;
+    get isNil(): boolean;
+    abstract equals(other: YuValue): ExecutionCommand;
+    abstract compare(other: YuValue): ExecutionCommand;
+    isSame(other: YuValue): ExecutionCommand;
+}

package/dist/interpreter/primitives/YuValue.js

@@ -0,0 +1,40 @@
+import { StepCommand, } from "../components/kernel/commands.js";
+import { boolean } from "../utils.js";
+/**
+ * Base class for all Yukigo values.
+ */
+export class YuValue {
+    getType() {
+        return this.constructor.name.replace("Yu", "");
+    }
+    realize() {
+        return new StepCommand(this);
+    }
+    // Capability Accessors (Delegation)
+    get asSummable() {
+        return undefined;
+    }
+    get asNumeric() {
+        return undefined;
+    }
+    get asSequence() {
+        return undefined;
+    }
+    get asLogic() {
+        return undefined;
+    }
+    get asComparable() {
+        return undefined;
+    }
+    get asStepResult() {
+        return undefined;
+    }
+    get isNil() {
+        return false;
+    }
+    isSame(other) {
+        if (this.getType() !== other.getType())
+            return boolean(false);
+        return this.equals(other);
+    }
+}

package/dist/interpreter/primitives/capabilities.d.ts

@@ -0,0 +1,90 @@
+import { ExecutionCommand } from "../components/kernel/commands.js";
+import { YuValue } from "./YuValue.js";
+/**
+ * Capability for addition and concatenation.
+*/
+export interface Summable {
+    plus(other: YuValue): ExecutionCommand;
+    plusWithNumber(left: YuValue): ExecutionCommand;
+    plusWithString(left: YuValue): ExecutionCommand;
+}
+export type YuSummable = YuValue & Summable;
+/**
+ * Capability for numeric operations.
+*/
+export interface Numeric extends Summable {
+    readonly value: number;
+    minus(other: YuValue): ExecutionCommand;
+    multiply(other: YuValue): ExecutionCommand;
+    divide(other: YuValue): ExecutionCommand;
+    modulo(other: YuValue): ExecutionCommand;
+    power(other: YuValue): ExecutionCommand;
+    min(other: YuValue): ExecutionCommand;
+    max(other: YuValue): ExecutionCommand;
+    round(): ExecutionCommand;
+    abs(): ExecutionCommand;
+    ceil(): ExecutionCommand;
+    floor(): ExecutionCommand;
+    negation(): ExecutionCommand;
+    sqrt(): ExecutionCommand;
+    minusWithNumber(left: YuValue): ExecutionCommand;
+    multiplyWithNumber(left: YuValue): ExecutionCommand;
+    divideWithNumber(left: YuValue): ExecutionCommand;
+    moduloWithNumber(left: YuValue): ExecutionCommand;
+    powerWithNumber(left: YuValue): ExecutionCommand;
+    minWithNumber(left: YuValue): ExecutionCommand;
+    maxWithNumber(left: YuValue): ExecutionCommand;
+}
+export type YuNumeric = YuValue & Numeric;
+/**
+ * Capability for sequences.
+ */
+export interface Sequence {
+    step(): ExecutionCommand;
+    realize(): ExecutionCommand;
+    size(): ExecutionCommand;
+    concat(other: YuValue): ExecutionCommand;
+    concatWithArray(arr: YuValue): ExecutionCommand;
+    concatWithString(str: YuValue): ExecutionCommand;
+    [Symbol.iterator](): Iterator<YuValue>;
+    getType(): string;
+    toJSON(): unknown;
+    readonly isNil: boolean;
+    readonly asStepResult?: StepResult;
+}
+export type YuSequence = YuValue & Sequence;
+/**
+ * Capability for logical operations.
+ */
+export interface Logic {
+    readonly value: boolean;
+    not(): ExecutionCommand;
+    toJSON(): unknown;
+}
+export type YuLogic = YuValue & Logic;
+/**
+ * Capability for comparisons.
+ */
+export interface Comparable {
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    equalsWithNumber(left: YuValue): ExecutionCommand;
+    equalsWithBoolean(left: YuValue): ExecutionCommand;
+    equalsWithString(left: YuValue): ExecutionCommand;
+    equalsWithArray(left: YuValue): ExecutionCommand;
+    equalsWithNil(left: YuValue): ExecutionCommand;
+    compareWithNumber(left: YuValue): ExecutionCommand;
+    compareWithBoolean(left: YuValue): ExecutionCommand;
+    compareWithString(left: YuValue): ExecutionCommand;
+    compareWithArray(left: YuValue): ExecutionCommand;
+    compareWithNil(left: YuValue): ExecutionCommand;
+}
+export type YuComparable = YuValue & Comparable;
+/**
+ * Result of stepping a sequence.
+ */
+export interface StepResult {
+    readonly head: YuValue;
+    readonly tail: YuSequence | null;
+}
+export type YuStepResult = YuValue & StepResult;

package/dist/interpreter/primitives/capabilities.js

@@ -0,0 +1 @@
+export {};

package/dist/interpreter/primitives/entities/LazyList.d.ts

@@ -0,0 +1,48 @@
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+import { RuntimeContext } from "../../components/RuntimeContext.js";
+import { Sequence, StepResult, YuSequence, YuStepResult } from "../capabilities.js";
+import { YuValue } from "../YuValue.js";
+/**
+ * Represents the result of forcing one step of a LazyList.
+ * If null, the list is empty.
+ */
+export declare class LazyStepResult extends YuValue implements StepResult {
+    readonly head: YuValue;
+    readonly tail: YuSequence | null;
+    constructor(head: YuValue, tail: YuSequence | null);
+    get asStepResult(): YuStepResult;
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    toString(): string;
+    toJSON(): unknown;
+}
+/**
+ * A LazyList represents a potentially infinite sequence of values evaluated on demand.
+ */
+export declare class LazyList extends YuValue implements Sequence {
+    private readonly producer;
+    readonly identifier: string;
+    readonly capturedContext?: RuntimeContext | undefined;
+    private memoized;
+    constructor(producer: (ctx?: RuntimeContext) => ExecutionCommand, identifier?: string, capturedContext?: RuntimeContext | undefined);
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    get asSequence(): YuSequence;
+    [Symbol.iterator](): Iterator<YuValue>;
+    /**
+     * Evaluates the first element of the list and returns it along with the tail.
+     */
+    step(): ExecutionCommand;
+    size(): ExecutionCommand;
+    realize(): ExecutionCommand;
+    concat(other: YuValue): ExecutionCommand;
+    concatWithArray(arr: YuValue): ExecutionCommand;
+    concatWithString(str: YuValue): ExecutionCommand;
+    private createLazyConcat;
+    toJSON(): {
+        identifier: string;
+        memoized: unknown;
+    };
+    toString(): string;
+}
+export declare function isLazyList(prim: unknown): prim is LazyList;