yukigo 0.2.3 → 0.3.2

package/src/interpreter/components/runtimes/LazyRuntime.ts

@@ -1,334 +1,226 @@
-import {
-  PrimitiveValue,
-  RangeExpression,
-  ConsExpression,
-  isLazyList,
-  ListBinaryOperation,
-  LazyList,
-} from "yukigo-ast";
-import { ExpressionEvaluator } from "../../utils.js";
-import {
-  createMemoizedStream,
-  InternalConsState,
-  isMemoizedList,
-} from "../PatternMatcher.js";
-import {
-  Continuation,
-  idContinuation,
-  Thunk,
-  trampoline,
-} from "../../trampoline.js";
-import { RuntimeContext } from "../RuntimeContext.js";
-
-export class LazyRuntime {
-  constructor(private context: RuntimeContext) {}
-
-  public realizeList<R = PrimitiveValue[]>(
-    val: PrimitiveValue,
-    k: Continuation<PrimitiveValue[], R>,
-  ): Thunk<R> {
-    if (Array.isArray(val)) return k(val);
-    if (typeof val === "string") return k(val.split(""));
-    if (isLazyList(val)) {
-      const result: PrimitiveValue[] = [];
-      const iter = val.generator();
-
-      const next = (): Thunk<R> => {
-        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}`);
-  }
-
-  public evaluateRange(
-    node: RangeExpression,
-    evaluator: ExpressionEvaluator,
-    k: Continuation<PrimitiveValue>,
-  ): Thunk<PrimitiveValue> {
-    return evaluator.evaluate(node.start, (startVal) => {
-      if (typeof startVal !== "number")
-        throw new Error("Range start must be a number");
-
-      const hasEnd = node.end != null;
-
-      const finishWithStep = (step: number): Thunk<PrimitiveValue> => {
-        if (!hasEnd) {
-          return k(
-            createMemoizedStream(function* () {
-              let current = startVal;
-              while (true) {
-                yield current;
-                current += step;
-              }
-            }),
-          );
-        }
-
-        return evaluator.evaluate(node.end!, (endVal) => {
-          if (typeof endVal !== "number")
-            throw new Error("Range end must be a number");
-
-          const cond =
-            step > 0 ? (c: number) => c <= endVal : (c: number) => c >= endVal;
-
-          if (this.context.config.lazyLoading) {
-            return k(
-              createMemoizedStream(function* () {
-                let current = startVal;
-                while (cond(current)) {
-                  yield current;
-                  current += step;
-                }
-              }),
-            );
-          }
-
-          const result: number[] = [];
-          let current = startVal;
-          while (cond(current)) {
-            result.push(current);
-            current += step;
-          }
-          return k(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);
-    });
-  }
-
-  public evaluateCons(
-    node: ConsExpression,
-    evaluator: ExpressionEvaluator,
-    k: Continuation<PrimitiveValue>,
-  ): Thunk<PrimitiveValue> {
-    const ctx = this.context;
-    const capturedEnv = ctx.clone();
-    return evaluator.evaluate(node.head, (head) => {
-      if (ctx.config.lazyLoading) {
-        const consState: InternalConsState = {
-          head,
-          tailExpr: node.tail,
-          evaluator,
-          capturedEnv,
-          realizedTail: undefined,
-        };
-
-        const consList: LazyList = {
-          type: "LazyList",
-          generator: function* () {
-            let current: any = 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}`,
-                );
-              }
-            }
-          },
-        };
-
-        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 as string) + tail);
-        if (isLazyList(tail) || !Array.isArray(tail))
-          throw new Error("Expected Array in eager Cons");
-        return k([head, ...tail]);
-      });
-    });
-  }
-
-  public evaluateConcat(
-    left: PrimitiveValue,
-    right: PrimitiveValue,
-    k: Continuation<PrimitiveValue>,
-  ): Thunk<PrimitiveValue> {
-    if (this.context.config.lazyLoading) {
-      return k(
-        createMemoizedStream(function* () {
-          if (Array.isArray(left)) yield* left;
-          else if (typeof left === "string") yield* (left as string).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 as string).split("");
-          else if (isLazyList(right)) yield* right.generator();
-          else throw new Error("Invalid right operand for lazy Concat");
-        }),
-      );
-    }
-
-    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));
-        });
-    });
-  }
-
-  public evaluateConcatLazy(
-    node: ListBinaryOperation,
-    evaluator: ExpressionEvaluator,
-    k: Continuation<PrimitiveValue>,
-  ): Thunk<PrimitiveValue> {
-    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: PrimitiveValue;
-          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");
-        }),
-      );
-    });
-  }
-  public deepEqual<R = boolean>(
-    a: PrimitiveValue,
-    b: PrimitiveValue,
-    k: Continuation<boolean, R>,
-  ): Thunk<R> {
-    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);
-        })
-      );
-    }
-
-    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
-  }
-  private isPlainObject(val: unknown): val is Record<string, any> {
-    return val !== null && typeof val === "object"
-      && !isLazyList(val) && !Array.isArray(val);
-  }
-  private isCollection(val: unknown): val is PrimitiveValue[] | LazyList {
-    return Array.isArray(val) || isLazyList(val);
-  }
-
-  private isListLike(val: unknown): val is string | PrimitiveValue[] | LazyList {
-    return Array.isArray(val) || isLazyList(val) || typeof val === "string";
-  }
-  private deepEqualCollection<R>(
-    a: PrimitiveValue[],
-    b: PrimitiveValue[],
-    index: number,
-    k: Continuation<boolean, R>,
-  ): Thunk<R> {
-    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);
-    });
-  }
-
-  private deepEqualObject<R>(
-    a: Record<string, any>,
-    b: Record<string, any>,
-    k: Continuation<boolean, R>,
-  ): Thunk<R> {
-    const keys = Object.keys(a);
-    if (keys.length !== Object.keys(b).length) return k(false);
-    const checkNext = (index: number): Thunk<R> => {
-      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);
-  }
-}
+import { RangeExpression, ConsExpression } from "yukigo-ast";
+import { error, raise } from "../../utils.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+import {
+  ExecutionCommand,
+  StepCommand,
+  BindCommand,
+} from "../kernel/commands.js";
+import { EqualityComparer } from "../EqualityComparer.js";
+import { YuValue } from "../../primitives/YuValue.js";
+import { YuSequence } from "../../primitives/capabilities.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";
+import { Evaluator } from "../evaluators/BaseEvaluator.js";
+
+export class LazyRuntime {
+  constructor(private context: RuntimeContext) {}
+
+  /**
+   * Realizes a list or lazy list into a YuArray.
+   */
+  public realizeList(val: YuValue): ExecutionCommand {
+    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()}`,
+      ),
+    );
+  }
+
+  public evaluateRange(
+    node: RangeExpression,
+    evaluator: Evaluator,
+  ): ExecutionCommand {
+    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: number): ExecutionCommand => {
+        const cond = (c: number, end: number) =>
+          step > 0 ? c <= end : c >= end;
+
+        const createLazyRange = (
+          val: number,
+          end?: number,
+        ): LazyList | null => {
+          if (end !== undefined && !cond(val, end)) return null;
+
+          return new LazyList((): ExecutionCommand => {
+            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 new StepCommand(createLazyRange(startNum)!);
+        }
+
+        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) {
+            const range = createLazyRange(startNum, endNum);
+            return new StepCommand(range || YuNil.getInstance());
+          }
+
+          const result: YuValue[] = [];
+          let current = startNum;
+          while (cond(current, endNum)) {
+            result.push(new YuNumber(current));
+            current += step;
+          }
+          return new StepCommand(new YuArray(result));
+        });
+      };
+
+      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);
+      });
+    });
+  }
+
+  public evaluateCons(
+    node: ConsExpression,
+    evaluator: Evaluator,
+  ): ExecutionCommand {
+    const ctx = this.context;
+    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 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);
+    }
+
+    // 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"),
+        );
+      });
+    });
+  }
+  private arrayToLazyList(arr: YuValue[], index: number = 0): LazyList | null {
+    if (index >= arr.length) return null;
+    return new LazyList(() => {
+      return new StepCommand(
+        new LazyStepResult(arr[index], this.arrayToLazyList(arr, index + 1)),
+      );
+    });
+  }
+  public evaluateConcat(left: YuSequence, right: YuSequence): ExecutionCommand {
+    if (this.context.config.lazyLoading) {
+      const createConcatList = (L: YuSequence, R: YuSequence): LazyList => {
+        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));
+    }
+
+    return left.concat(right);
+  }
+}