yukigo 0.1.0 → 0.2.0

package/src/interpreter/components/logic/LogicTranslator.ts

@@ -0,0 +1,149 @@
+import {
+  Expression,
+  LiteralPattern,
+  Pattern,
+  PrimitiveValue,
+  SymbolPrimitive,
+  Variable,
+  VariablePattern,
+  EnvStack,
+  isPattern,
+  NumberPrimitive,
+  StringPrimitive,
+  BooleanPrimitive,
+  ListPrimitive,
+  ListPattern,
+  ConsExpression,
+  ConsPattern,
+  FunctorPattern,
+} from "yukigo-ast";
+import { Substitution, instantiate } from "./LogicResolver.js";
+import { ExpressionEvaluator } from "../../utils.js";
+import { InterpreterError } from "../../errors.js";
+import {
+  idContinuation,
+  trampoline,
+  Continuation,
+  Thunk,
+} from "../../trampoline.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+
+export class LogicTranslator {
+  constructor(
+    private evaluator: ExpressionEvaluator,
+    private ctx: RuntimeContext,
+  ) {}
+
+  public patternToPrimitive(pat: Pattern): PrimitiveValue | undefined {
+    if (pat instanceof LiteralPattern) {
+      const primitive = pat.name;
+      return primitive.value;
+    }
+    if (pat instanceof ListPattern) {
+      return pat.elements.map((el) => this.patternToPrimitive(el));
+    }
+    if (pat instanceof ConsPattern) {
+      const head = this.patternToPrimitive(pat.left);
+      const tail = this.patternToPrimitive(pat.right);
+      if (Array.isArray(tail)) {
+        return [head, ...tail];
+      }
+      return [head, tail];
+    }
+    // Return the pattern itself for non-primitive logic terms (VariablePattern, FunctorPattern, etc.)
+    return pat as any;
+  }
+
+  public expressionToPattern<R = Pattern>(
+    expr: Expression,
+    k: Continuation<Pattern, R>,
+  ): Thunk<R> {
+    if (isPattern(expr)) return k(expr);
+
+    if (expr instanceof ListPrimitive) {
+      const results: Pattern[] = [];
+      const next = (index: number): Thunk<R> => {
+        if (index >= expr.value.length) return k(new ListPattern(results));
+        return this.expressionToPattern(expr.value[index], (p) => {
+          results.push(p);
+          return () => next(index + 1);
+        });
+      };
+      return next(0);
+    }
+
+    if (expr instanceof ConsExpression) {
+      return this.expressionToPattern(expr.head, (headPat) => {
+        return () =>
+          this.expressionToPattern(expr.tail, (tailPat) => {
+            return k(new ConsPattern(headPat, tailPat));
+          });
+      });
+    }
+
+    if (expr instanceof Variable || expr instanceof SymbolPrimitive) {
+      const name =
+        expr instanceof Variable ? expr.identifier.value : expr.value;
+      if (this.ctx.isDefined(name)) {
+        return this.evaluator.evaluate(expr, (val) => {
+          return k(this.primitiveToPattern(val));
+        });
+      }
+      return k(
+        new VariablePattern(expr instanceof Variable ? expr.identifier : expr),
+      );
+    }
+    return this.evaluator.evaluate(expr, (val) => {
+      return k(this.primitiveToPattern(val));
+    });
+  }
+
+  public primitiveToPattern(val: PrimitiveValue): Pattern {
+    if (isPattern(val as any)) {
+      return val as any;
+    }
+    if (typeof val === "number") {
+      return new LiteralPattern(new NumberPrimitive(val));
+    }
+    if (typeof val === "string") {
+      return new LiteralPattern(new StringPrimitive(val));
+    }
+    if (typeof val === "boolean") {
+      return new LiteralPattern(new BooleanPrimitive(val));
+    }
+    if (Array.isArray(val)) {
+      return new ListPattern(val.map((v) => this.primitiveToPattern(v)));
+    }
+    if (
+      val &&
+      typeof val === "object" &&
+      "type" in val &&
+      val.type === "Object"
+    ) {
+      // Convert RuntimeObject to FunctorPattern for logic matching
+      const args: Pattern[] = [];
+      for (const [_, fieldVal] of (val as any).fields) {
+        args.push(this.primitiveToPattern(fieldVal));
+      }
+      return new FunctorPattern(
+        new SymbolPrimitive((val as any).className || (val as any).identifier),
+        args,
+      );
+    }
+
+    throw new InterpreterError(
+      "primitiveToPattern",
+      `Cannot convert value ${val} to Logic Pattern`,
+    );
+  }
+
+  public instantiateExpressionAsPattern<R = Pattern>(
+    expr: Expression,
+    substs: Substitution,
+    k: Continuation<Pattern, R>,
+  ): Thunk<R> {
+    return this.expressionToPattern(expr, (patternBase) => {
+      return k(instantiate(patternBase, substs));
+    });
+  }
+}

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

@@ -0,0 +1,227 @@
+import {
+  EquationRuntime,
+  PrimitiveValue,
+  UnguardedBody,
+  Sequence,
+  Return,
+  Function,
+  RuntimeFunction,
+  isRuntimeFunction,
+} from "yukigo-ast";
+import { Bindings } from "../../index.js";
+import { PatternMatcher } from "../PatternMatcher.js";
+import { ExpressionEvaluator } from "../../utils.js";
+import { InterpreterError } from "../../errors.js";
+import { EnvBuilderVisitor } from "../EnvBuilder.js";
+import { Continuation, CPSThunk, Thunk, valueToCPS } from "../../trampoline.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+import { InterpreterVisitor } from "../Visitor.js";
+
+class NonExhaustivePatterns extends InterpreterError {
+  constructor(funcName: string) {
+    super("PatternMatch", `Non-exhaustive patterns in '${funcName}'`);
+  }
+}
+
+type EvaluatorFactory = (ctx: RuntimeContext) => ExpressionEvaluator;
+
+export class FunctionRuntime {
+  constructor(private context: RuntimeContext) {}
+
+  public apply(
+    func: RuntimeFunction,
+    args: PrimitiveValue[],
+    k: Continuation<PrimitiveValue>,
+  ): Thunk<PrimitiveValue> {
+    const funcName = func.identifier;
+    const equations = func.equations;
+    const oldEnv = this.context.env;
+
+    if (this.context.config.debug)
+      console.log(
+        `[FunctionRuntime] Applying function: ${funcName} with args:`,
+        args,
+      );
+
+    const tryNextEquation = (eqIndex: number): Thunk<PrimitiveValue> => {
+      if (eqIndex >= equations.length) {
+        this.context.setEnv(oldEnv);
+        throw new NonExhaustivePatterns(funcName);
+      }
+
+      const eq = equations[eqIndex];
+      if (eq.patterns.length !== args.length)
+        return () => tryNextEquation(eqIndex + 1);
+
+      const bindings: Bindings = [];
+
+      return this.patternsMatch(eq, args, bindings, (isMatch) => {
+        if (!isMatch) return () => tryNextEquation(eqIndex + 1);
+
+        if (this.context.config.debug)
+          console.log(
+            `[FunctionRuntime] Match successful for ${funcName} equation ${eqIndex}`,
+          );
+
+        const localEnv = new Map<string, PrimitiveValue>(bindings);
+        if (func.closure) this.context.setEnv(func.closure);
+        this.context.pushEnv(localEnv);
+
+        const wrappedK = (res: PrimitiveValue) => {
+          this.context.setEnv(oldEnv);
+          return k(res);
+        };
+
+        const evaluatorFactory: EvaluatorFactory = (ctx) =>
+          new InterpreterVisitor(ctx);
+
+        const body = eq.body;
+
+        // UnguardedBody
+        if (body instanceof UnguardedBody)
+          return this.evaluateSequence(
+            body.sequence,
+            this.context,
+            evaluatorFactory,
+            wrappedK,
+          );
+
+        // GuardedBody
+        return () => {
+          if (Array.isArray(body) && body.length > 0) {
+            const prototypeBody = body[0].body;
+            if (prototypeBody instanceof Sequence)
+              this.preloadDefinitions(prototypeBody, evaluatorFactory);
+          }
+
+          const tryNextGuard = (guardIndex: number): Thunk<PrimitiveValue> => {
+            if (guardIndex >= body.length) {
+              this.context.setEnv(oldEnv);
+              return () => tryNextEquation(eqIndex + 1);
+            }
+
+            const evaluator = evaluatorFactory(this.context);
+            const guard = body[guardIndex];
+            return evaluator.evaluate(guard.condition, (cond) => {
+              if (cond !== true) return () => tryNextGuard(guardIndex + 1);
+
+              if (!(guard.body instanceof Sequence))
+                return evaluator.evaluate(guard.body, wrappedK);
+
+              return this.evaluateSequence(
+                guard.body,
+                this.context,
+                evaluatorFactory,
+                wrappedK,
+              );
+            });
+          };
+
+          return tryNextGuard(0);
+        };
+      });
+    };
+
+    return tryNextEquation(0);
+  }
+
+  public applyArguments(
+    func: RuntimeFunction,
+    args: (PrimitiveValue | (() => PrimitiveValue))[],
+  ): CPSThunk<PrimitiveValue> {
+    if (args.length < func.arity) {
+      return valueToCPS({
+        ...func,
+        pendingArgs: args,
+      });
+    }
+
+    const argsToConsume = args.slice(0, func.arity);
+    const remainingArgs = args.slice(func.arity);
+
+    const evaluatedArgs = argsToConsume.map((arg) =>
+      typeof arg === "function" ? arg() : arg,
+    );
+
+    return (cont) => () =>
+      this.apply(func, evaluatedArgs, (result) => {
+        if (remainingArgs.length > 0) {
+          if (isRuntimeFunction(result)) {
+            const nextArgs = result.pendingArgs
+              ? [...result.pendingArgs, ...remainingArgs]
+              : remainingArgs;
+
+            return this.applyArguments(result, nextArgs)(cont);
+          } else {
+            throw new InterpreterError(
+              "Application",
+              `Too many arguments provided. Result was '${result}' (not a function), but had ${remainingArgs.length} args left.`,
+            );
+          }
+        }
+        return cont(result);
+      });
+  }
+
+  private preloadDefinitions(
+    seq: Sequence,
+    evaluatorFactory: EvaluatorFactory,
+  ): void {
+    const ctx = new RuntimeContext();
+    new EnvBuilderVisitor(ctx).build(seq.statements);
+    const evaluator = evaluatorFactory(ctx);
+
+    for (const stmt of seq.statements) {
+      if (stmt instanceof Function || stmt instanceof Return) continue;
+      evaluator.evaluate(stmt, (val) => val);
+    }
+  }
+
+  private patternsMatch(
+    eq: EquationRuntime,
+    args: PrimitiveValue[],
+    bindings: Bindings,
+    k: Continuation<boolean>,
+  ): Thunk<boolean> {
+    const matchNext = (index: number): Thunk<boolean> => {
+      if (index >= args.length) return k(true);
+      const matcher = new PatternMatcher(args[index], bindings, this.context);
+      return eq.patterns[index].accept(matcher)((isMatch) => {
+        if (!isMatch) return k(false);
+        return () => matchNext(index + 1);
+      });
+    };
+    return matchNext(0);
+  }
+
+  private evaluateSequence(
+    seq: Sequence,
+    ctx: RuntimeContext,
+    evaluatorFactory: EvaluatorFactory,
+    k: Continuation<PrimitiveValue>,
+  ): Thunk<PrimitiveValue> {
+    new EnvBuilderVisitor(ctx).build(seq.statements);
+    const evaluator = evaluatorFactory(ctx);
+
+    const evaluateNext = (
+      index: number,
+      lastResult: PrimitiveValue,
+    ): Thunk<PrimitiveValue> => {
+      if (index >= seq.statements.length) return k(lastResult);
+
+      const stmt = seq.statements[index];
+      if (stmt instanceof Function)
+        return () => evaluateNext(index + 1, lastResult);
+
+      if (stmt instanceof Return) {
+        return evaluator.evaluate(stmt.body, k);
+      } else {
+        return evaluator.evaluate(stmt, (result) => {
+          return () => evaluateNext(index + 1, result);
+        });
+      }
+    };
+
+    return evaluateNext(0, undefined);
+  }
+}

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

@@ -0,0 +1,334 @@
+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);
+  }
+}