yukigo 0.2.3 → 0.3.2

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

@@ -1,269 +1,142 @@
-import { isLazyList, } from "yukigo-ast";
-import { createMemoizedStream, isMemoizedList, } from "../PatternMatcher.js";
-import { idContinuation, trampoline, } from "../../trampoline.js";
+import { error, raise } from "../../utils.js";
+import { StepCommand, BindCommand, } from "../kernel/commands.js";
+import { YuValue } from "../../primitives/YuValue.js";
+import { YuNil } from "../../primitives/scalars/YuNil.js";
+import { YuNumber } from "../../primitives/scalars/YuNumber.js";
+import { YuArray } from "../../primitives/sequences/YuArray.js";
+import { YuString } from "../../primitives/sequences/YuString.js";
+import { isLazyList, LazyList, LazyStepResult, } from "../../primitives/entities/LazyList.js";
 export class LazyRuntime {
     context;
     constructor(context) {
         this.context = context;
     }
-    realizeList(val, k) {
-        if (Array.isArray(val))
-            return k(val);
-        if (typeof val === "string")
-            return k(val.split(""));
-        if (isLazyList(val)) {
-            const result = [];
-            const iter = val.generator();
-            const next = () => {
-                const step = iter.next();
-                if (step.done)
-                    return k(result);
-                if (step.value === undefined)
-                    throw new Error("LazyList yielded undefined");
-                result.push(step.value);
-                return () => next();
-            };
-            return next();
-        }
-        throw new Error(`Expected List or LazyList, got ${typeof val}`);
+    /**
+     * Realizes a list or lazy list into a YuArray.
+     */
+    realizeList(val) {
+        if (this.context.config.debug)
+            console.log(`[LazyRuntime] realizeList: input`, val);
+        if (val instanceof YuNil)
+            return new StepCommand(new YuArray([]));
+        const seq = val.asSequence;
+        if (seq)
+            return seq.realize();
+        return raise(error("LazyRuntime.realizeList", `Expected Sequence, got ${val.getType()}`));
     }
-    evaluateRange(node, evaluator, k) {
-        return evaluator.evaluate(node.start, (startVal) => {
-            if (typeof startVal !== "number")
-                throw new Error("Range start must be a number");
+    evaluateRange(node, evaluator) {
+        return new BindCommand(evaluator.evaluate(node.start), (startVal) => {
+            const startNum = startVal.toJSON();
+            if (typeof startNum !== "number")
+                return raise(error("LazyRuntime.evaluateRange", "Range start must be a number"));
             const hasEnd = node.end != null;
             const finishWithStep = (step) => {
+                const cond = (c, end) => step > 0 ? c <= end : c >= end;
+                const createLazyRange = (val, end) => {
+                    if (end !== undefined && !cond(val, end))
+                        return null;
+                    return new LazyList(() => {
+                        const tail = createLazyRange(val + step, end);
+                        return new StepCommand(new LazyStepResult(new YuNumber(val), tail));
+                    }, `Range(${val})`);
+                };
+                // if the list is infinite
                 if (!hasEnd) {
-                    return k(createMemoizedStream(function* () {
-                        let current = startVal;
-                        while (true) {
-                            yield current;
-                            current += step;
-                        }
-                    }));
+                    return new StepCommand(createLazyRange(startNum));
                 }
-                return evaluator.evaluate(node.end, (endVal) => {
-                    if (typeof endVal !== "number")
-                        throw new Error("Range end must be a number");
-                    const cond = step > 0 ? (c) => c <= endVal : (c) => c >= endVal;
+                return new BindCommand(evaluator.evaluate(node.end), (endVal) => {
+                    const endNum = endVal.toJSON();
+                    if (typeof endNum !== "number")
+                        return raise(error("LazyRuntime.evaluateRange", "Range end must be a number"));
                     if (this.context.config.lazyLoading) {
-                        return k(createMemoizedStream(function* () {
-                            let current = startVal;
-                            while (cond(current)) {
-                                yield current;
-                                current += step;
-                            }
-                        }));
+                        const range = createLazyRange(startNum, endNum);
+                        return new StepCommand(range || YuNil.getInstance());
                     }
                     const result = [];
-                    let current = startVal;
-                    while (cond(current)) {
-                        result.push(current);
+                    let current = startNum;
+                    while (cond(current, endNum)) {
+                        result.push(new YuNumber(current));
                         current += step;
                     }
-                    return k(result);
+                    return new StepCommand(new YuArray(result));
                 });
             };
-            if (node.step) {
-                return evaluator.evaluate(node.step, (secondVal) => {
-                    if (typeof secondVal !== "number")
-                        throw new Error("Range step must be a number");
-                    const step = secondVal - startVal;
-                    if (step === 0)
-                        throw new Error("Range step cannot be zero");
-                    return finishWithStep(step);
-                });
-            }
-            return finishWithStep(1);
+            if (!node.step)
+                return finishWithStep(1);
+            return new BindCommand(evaluator.evaluate(node.step), (secondVal) => {
+                const secondNum = secondVal.toJSON();
+                if (typeof secondNum !== "number")
+                    return raise(error("LazyRuntime.evaluateRange", "Range step must be a number"));
+                const step = secondNum - startNum;
+                if (step === 0)
+                    return raise(error("LazyRuntime.evaluateRange", "Range step cannot be zero"));
+                return finishWithStep(step);
+            });
         });
     }
-    evaluateCons(node, evaluator, k) {
+    evaluateCons(node, evaluator) {
         const ctx = this.context;
-        const capturedEnv = ctx.clone();
-        return evaluator.evaluate(node.head, (head) => {
-            if (ctx.config.lazyLoading) {
-                const consState = {
-                    head,
-                    tailExpr: node.tail,
-                    evaluator,
-                    capturedEnv,
-                    realizedTail: undefined,
-                };
-                const consList = {
-                    type: "LazyList",
-                    generator: function* () {
-                        let current = consState;
-                        while (current !== undefined && current !== null) {
-                            if (current.tailExpr !== undefined) {
-                                yield current.head;
-                                if (current.realizedTail === undefined) {
-                                    const prevEnv = ctx.env;
-                                    ctx.setEnv(current.capturedEnv);
-                                    try {
-                                        current.realizedTail = trampoline(current.evaluator.evaluate(current.tailExpr, idContinuation));
-                                    }
-                                    finally {
-                                        ctx.setEnv(prevEnv);
-                                    }
-                                }
-                                current = current.realizedTail;
-                            }
-                            else if (isLazyList(current)) {
-                                const memoized = current;
-                                if (isMemoizedList(memoized) && memoized._consState) {
-                                    current = memoized._consState;
-                                }
-                                else {
-                                    const iter = current.generator();
-                                    let step = iter.next();
-                                    while (!step.done) {
-                                        yield step.value;
-                                        step = iter.next();
-                                    }
-                                    break;
-                                }
-                            }
-                            else if (Array.isArray(current) ||
-                                typeof current === "string") {
-                                for (const x of current)
-                                    yield x;
-                                break;
-                            }
-                            else {
-                                throw new Error(`Invalid tail type for Cons: ${typeof current}`);
-                            }
+        if (ctx.config.lazyLoading) {
+            const capturedCtx = ctx.clone();
+            const conjoinedLazyList = new LazyList(() => {
+                if (!capturedCtx.evaluatorFactory)
+                    return raise(error("LazyRuntime.evaluateRange", "EvaluatorFactory not initialized"));
+                const subEvaluator = capturedCtx.evaluatorFactory(capturedCtx);
+                return new BindCommand(subEvaluator.evaluate(node.head), (head) => {
+                    return new BindCommand(subEvaluator.evaluate(node.tail), (tailRes) => {
+                        if (tailRes instanceof YuNil) {
+                            return new StepCommand(new LazyStepResult(head, null));
                         }
-                    },
-                };
-                const memoized = createMemoizedStream(() => consList.generator());
-                memoized._consState = consState;
-                return k(memoized);
-            }
-            // Eager behavior
-            return evaluator.evaluate(node.tail, (tail) => {
-                if (typeof tail === "string")
-                    return k(head + tail);
-                if (isLazyList(tail) || !Array.isArray(tail))
-                    throw new Error("Expected Array in eager Cons");
-                return k([head, ...tail]);
-            });
-        });
-    }
-    evaluateConcat(left, right, k) {
-        if (this.context.config.lazyLoading) {
-            return k(createMemoizedStream(function* () {
-                if (Array.isArray(left))
-                    yield* left;
-                else if (typeof left === "string")
-                    yield* left.split("");
-                else if (isLazyList(left))
-                    yield* left.generator();
-                else
-                    throw new Error("Invalid left operand for lazy Concat");
-                if (Array.isArray(right))
-                    yield* right;
-                else if (typeof right === "string")
-                    yield* right.split("");
-                else if (isLazyList(right))
-                    yield* right.generator();
-                else
-                    throw new Error("Invalid right operand for lazy Concat");
-            }));
+                        const tailSeq = tailRes.asSequence;
+                        if (tailSeq) {
+                            if (isLazyList(tailSeq))
+                                return new StepCommand(new LazyStepResult(head, tailSeq));
+                            return new StepCommand(new LazyStepResult(head, this.arrayToLazyList([...tailSeq])));
+                        }
+                        return raise(error("LazyRuntime.evaluateRange", `Invalid tail in cons: ${tailRes.getType()}`));
+                    });
+                });
+            }, "Cons", capturedCtx);
+            return new StepCommand(conjoinedLazyList);
         }
-        if (typeof left === "string" && typeof right === "string")
-            return k(left + right);
-        return this.realizeList(left, (lArr) => {
-            return () => this.realizeList(right, (rArr) => {
-                return k(lArr.concat(rArr));
+        // Eager behavior
+        return new BindCommand(evaluator.evaluate(node.head), (head) => {
+            return new BindCommand(evaluator.evaluate(node.tail), (tail) => {
+                if (tail instanceof YuString)
+                    return new StepCommand(new YuString(head.toJSON() + tail.toJSON()));
+                const tailSeq = tail.asSequence;
+                if (tailSeq instanceof YuArray) {
+                    return new StepCommand(new YuArray([head, ...tailSeq]));
+                }
+                return raise(error("LazyRuntime.evaluateRange", "Expected Array in eager Cons"));
             });
         });
     }
-    evaluateConcatLazy(node, evaluator, k) {
-        const ctx = this.context;
-        return evaluator.evaluate(node.left, (left) => {
-            const capturedEnv = ctx.clone();
-            return k(createMemoizedStream(function* () {
-                if (Array.isArray(left))
-                    yield* left;
-                else if (typeof left === "string")
-                    yield* left.split("");
-                else if (isLazyList(left))
-                    yield* left.generator();
-                else
-                    throw new Error("Invalid left operand for lazy Concat");
-                // right evaluates lazily on demand
-                const prevEnv = ctx.env;
-                ctx.setEnv(capturedEnv);
-                let right;
-                try {
-                    right = trampoline(evaluator.evaluate(node.right, idContinuation));
-                }
-                finally {
-                    ctx.setEnv(prevEnv);
-                }
-                if (Array.isArray(right))
-                    yield* right;
-                else if (typeof right === "string")
-                    yield* right.split("");
-                else if (isLazyList(right))
-                    yield* right.generator();
-                else
-                    throw new Error("Invalid right operand for lazy Concat");
-            }));
+    arrayToLazyList(arr, index = 0) {
+        if (index >= arr.length)
+            return null;
+        return new LazyList(() => {
+            return new StepCommand(new LazyStepResult(arr[index], this.arrayToLazyList(arr, index + 1)));
         });
     }
-    deepEqual(a, b, k) {
-        if (a === b)
-            return k(true);
-        const aIsListLike = this.isListLike(a);
-        const bIsListLike = this.isListLike(b);
-        const eitherIsCollection = this.isCollection(a) || this.isCollection(b);
-        if (eitherIsCollection && aIsListLike && bIsListLike) {
-            return this.realizeList(a, (valA) => () => this.realizeList(b, (valB) => {
-                if (valA.length !== valB.length)
-                    return k(false);
-                return this.deepEqualCollection(valA, valB, 0, k);
-            }));
+    evaluateConcat(left, right) {
+        if (this.context.config.lazyLoading) {
+            const createConcatList = (L, R) => {
+                return new LazyList(() => {
+                    return new BindCommand(L.step(), (stepRes) => {
+                        if (stepRes.isNil)
+                            return R.step();
+                        const stepResult = stepRes.asStepResult;
+                        if (!stepResult)
+                            return raise(error("LazyRuntime.evaluateRange", "Concat: step did not return StepResult"));
+                        return new StepCommand(new LazyStepResult(stepResult.head, stepResult.tail && stepResult.tail instanceof YuValue
+                            ? createConcatList(stepResult.tail, R)
+                            : R));
+                    });
+                }, "Concat");
+            };
+            return new StepCommand(createConcatList(left, right));
         }
-        if (eitherIsCollection)
-            return k(false); // colección vs número → false
-        if (this.isPlainObject(a) && this.isPlainObject(b))
-            return this.deepEqualObject(a, b, k);
-        return k(a == b); // primitivos: number, boolean, string==number
-    }
-    isPlainObject(val) {
-        return val !== null && typeof val === "object"
-            && !isLazyList(val) && !Array.isArray(val);
-    }
-    isCollection(val) {
-        return Array.isArray(val) || isLazyList(val);
-    }
-    isListLike(val) {
-        return Array.isArray(val) || isLazyList(val) || typeof val === "string";
-    }
-    deepEqualCollection(a, b, index, k) {
-        if (index >= a.length)
-            return k(true);
-        return this.deepEqual(a[index], b[index], (eq) => {
-            if (!eq)
-                return k(false);
-            return () => this.deepEqualCollection(a, b, index + 1, k);
-        });
-    }
-    deepEqualObject(a, b, k) {
-        const keys = Object.keys(a);
-        if (keys.length !== Object.keys(b).length)
-            return k(false);
-        const checkNext = (index) => {
-            if (index >= keys.length)
-                return k(true);
-            const key = keys[index];
-            return this.deepEqual(a[key], b[key], (eq) => {
-                if (!eq)
-                    return k(false);
-                return () => checkNext(index + 1);
-            });
-        };
-        return checkNext(0);
+        return left.concat(right);
     }
 }

package/dist/interpreter/components/runtimes/ObjectRuntime.d.ts

@@ -1,35 +1,38 @@
-import { PrimitiveValue, RuntimeFunction, RuntimeObject, EnvStack } from "yukigo-ast";
-import { Continuation, Thunk } from "../../trampoline.js";
+import { YuValue, RuntimeClass, RuntimeObject, RuntimeFunction } from "../../primitives/index.js";
 import { RuntimeContext } from "../RuntimeContext.js";
+import { ExecutionCommand } from "../kernel/commands.js";
+type OOPEntity = RuntimeClass | RuntimeObject;
+type OOPMatch = {
+    method: RuntimeFunction;
+    holder: RuntimeObject | RuntimeClass;
+};
 export declare class ObjectRuntime {
     private context;
     constructor(context: RuntimeContext);
-    /**
-     * Creates a new instance of an Object.
-     * Typically called by visitNew()
-     */
-    instantiate(className: string, identifier: string, fieldDefinitions: Map<string, PrimitiveValue>, methodDefinitions: Map<string, RuntimeFunction>): RuntimeObject;
     /**
      * Handles Method Calls (Message Passing).
      * Reuses FunctionRuntime to execute the method body.
      */
-    dispatch(receiver: PrimitiveValue, methodName: string, args: PrimitiveValue[], env: EnvStack, k: Continuation<PrimitiveValue>): Thunk<PrimitiveValue>;
+    dispatch(receiver: YuValue, methodName: string, args: YuValue[]): ExecutionCommand;
     /**
      * Handles calls to super() or super.method()
      */
-    dispatchSuper(currentEnv: EnvStack, methodName: string, args: PrimitiveValue[], k: Continuation<PrimitiveValue>): Thunk<PrimitiveValue>;
-    private createDispatchScope;
-    private getResolutionChain;
+    dispatchSuper(methodName: string, args: YuValue[]): ExecutionCommand;
+    getResolutionChain(receiver: RuntimeObject): OOPEntity[];
     private expandClassHierarchy;
-    private findMethodInChain;
+    private getClassDef;
+    findMethodInChain(chain: Array<OOPEntity>, methodName: string): OOPMatch | undefined;
     /**
      * Field Access (Get)
      * e.g. self.myField
      */
-    getField(receiver: PrimitiveValue, fieldName: string): PrimitiveValue;
+    getField(receiver: YuValue, fieldName: string): YuValue;
     /**
      * Field Mutation (Set)
      * e.g. self.myField = 10
      */
-    setField(receiver: PrimitiveValue, fieldName: string, value: PrimitiveValue): PrimitiveValue;
+    setField(obj: YuValue, fieldName: string, value: YuValue): YuValue;
+    private getReceiver;
+    dispatchPrimitive(receiver: YuValue, methodName: string, args: YuValue[]): ExecutionCommand;
 }
+export {};