yukigo 0.2.2 → 0.3.1

package/src/interpreter/index.ts

@@ -1,52 +1,50 @@
-import { PrimitiveValue, AST, EnvStack, ASTNode } from "yukigo-ast";
-import { InterpreterVisitor } from "./components/Visitor.js";
-import { EnvBuilderVisitor } from "./components/EnvBuilder.js";
-import { InterpreterError } from "./errors.js";
-import { createGlobalEnv } from "./utils.js";
-import { idContinuation, trampoline } from "./trampoline.js";
-import {
-  InterpreterConfig,
-  RuntimeContext,
-} from "./components/RuntimeContext.js";
-import { LazyRuntime } from "./components/runtimes/LazyRuntime.js";
-import { FunctionRuntime } from "./components/runtimes/FunctionRuntime.js";
-import { ObjectRuntime } from "./components/runtimes/ObjectRuntime.js";
-
-export type Bindings = [string, PrimitiveValue][];
-
-/**
- * The Interpreter class is responsible for evaluating the Abstract Syntax Tree (AST)
- * generated by the parsers.
- *
- * It manages the global execution environment and delegates the actual evaluation
- * of Expression nodes to a dedicated visitor.
- */
-export class Interpreter {
-  private context: RuntimeContext;
-
-  /**
-   * @param ast The Abstract Syntax Tree (AST) of the program to be interpreted.
-   */
-  constructor(ast: AST, config: InterpreterConfig = {}) {
-    this.context = new RuntimeContext(config);
-    const builder = new EnvBuilderVisitor(this.context);
-    builder.build(ast);
-  }
-
-  /**
-   * 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.
-   */
-  public evaluate(expr: ASTNode): PrimitiveValue {
-    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;
-    }
-  }
-}
+import { AST, ASTNode } from "yukigo-ast";
+import { EnvBuilderVisitor } from "./components/EnvBuilder.js";
+import {
+  RuntimeContext,
+} from "./components/RuntimeContext.js";
+import { YukigoKernel } from "./components/kernel/index.js";
+import { EvalCommand } from "./components/kernel/commands.js";
+import { YuValue } from "./primitives/index.js";
+import { InterpreterConfig } from "../utils/helpers.js";
+import { InterpreterVisitor } from "./components/evaluators/index.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.
+ *
+ * It manages the global execution environment and delegates the actual evaluation
+ * of Expression nodes to a dedicated visitor.
+ */
+export class Interpreter {
+  private context: RuntimeContext;
+
+  /**
+   * @param ast The Abstract Syntax Tree (AST) of the program to be interpreted.
+   */
+  constructor(ast: AST, config: Partial<InterpreterConfig> = {}) {
+    this.context = new RuntimeContext(config);
+    const builder = new EnvBuilderVisitor(this.context);
+    builder.build(ast);
+  }
+
+  /**
+   * 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.
+   */
+  public evaluate(expr: ASTNode): YuValue {
+    const visitor = new InterpreterVisitor(this.context);
+    const outputMode = this.context.config.outputMode;
+    const kernel = new YukigoKernel(visitor, outputMode);
+    return kernel.run(new EvalCommand(expr));
+  }
+
+  public getContext(): RuntimeContext {
+    return this.context;
+  }
+}

package/src/interpreter/primitives/YuValue.ts

@@ -0,0 +1,64 @@
+import {
+  ExecutionCommand,
+  StepCommand,
+} from "../components/kernel/commands.js";
+import { boolean } from "../utils.js";
+import {
+  YuNumeric,
+  YuSummable,
+  YuSequence,
+  YuLogic,
+  YuComparable,
+  YuStepResult,
+} from "./capabilities.js";
+import { YuBoolean } from "./scalars/YuBoolean.js";
+
+/**
+ * Base class for all Yukigo values.
+ */
+export abstract class YuValue {
+  abstract toString(seen?: Set<YuValue>): string;
+  abstract toJSON(keyOrSeen?: string | Set<YuValue>): unknown;
+
+  public getType(): string {
+    return this.constructor.name.replace("Yu", "");
+  }
+
+  public realize(): ExecutionCommand {
+    return new StepCommand(this);
+  }
+
+  // Capability Accessors (Delegation)
+  get asSummable(): YuSummable | undefined {
+    return undefined;
+  }
+  get asNumeric(): YuNumeric | undefined {
+    return undefined;
+  }
+  get asSequence(): YuSequence | undefined {
+    return undefined;
+  }
+  get asLogic(): YuLogic | undefined {
+    return undefined;
+  }
+  get asComparable(): YuComparable | undefined {
+    return undefined;
+  }
+  get asStepResult(): YuStepResult | undefined {
+    return undefined;
+  }
+
+  get isNil(): boolean {
+    return false;
+  }
+
+  // Comparison
+  public abstract equals(other: YuValue): ExecutionCommand;
+  public abstract compare(other: YuValue): ExecutionCommand;
+
+  public isSame(other: YuValue): ExecutionCommand {
+    if (this.getType() !== other.getType())
+      return boolean(false);
+    return this.equals(other);
+  }
+}

package/src/interpreter/primitives/capabilities.ts

@@ -0,0 +1,111 @@
+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/src/interpreter/primitives/entities/LazyList.ts

@@ -0,0 +1,225 @@
+import {
+  ExecutionCommand,
+  StepCommand,
+  BindCommand,
+} from "../../components/kernel/commands.js";
+import { RuntimeContext } from "../../components/RuntimeContext.js";
+import { InterpreterError, NotConcatenable } from "../../errors.js";
+import { boolean, error, raise } from "../../utils.js";
+import {
+  Sequence,
+  StepResult,
+  YuSequence,
+  YuStepResult,
+} from "../capabilities.js";
+import { YuBoolean } from "../index.js";
+import { YuNil } from "../scalars/YuNil.js";
+import { YuArray } from "../sequences/YuArray.js";
+import { YuValue } from "../YuValue.js";
+
+/**
+ * Represents the result of forcing one step of a LazyList.
+ * If null, the list is empty.
+ */
+export class LazyStepResult extends YuValue implements StepResult {
+  constructor(
+    public readonly head: YuValue,
+    public readonly tail: YuSequence | null,
+  ) {
+    super();
+  }
+
+  get asStepResult(): YuStepResult {
+    return this;
+  }
+
+  public equals(other: YuValue): ExecutionCommand {
+    return boolean(other === this);
+  }
+  public compare(other: YuValue): ExecutionCommand {
+    return raise(error("LazyStepResult", "Step results are not comparable"));
+  }
+  public toString(): string {
+    return `StepResult(${this.head}, ${this.tail})`;
+  }
+  public toJSON(): unknown {
+    return { head: this.head.toJSON(), tail: this.tail?.toJSON() };
+  }
+}
+
+/**
+ * A LazyList represents a potentially infinite sequence of values evaluated on demand.
+ */
+export class LazyList extends YuValue implements Sequence {
+  // Use 'undefined' for un-evaluated, 'null' for empty list.
+  private memoized: LazyStepResult | null | undefined = undefined;
+
+  constructor(
+    private readonly producer: (ctx?: RuntimeContext) => ExecutionCommand,
+    public readonly identifier: string = "lazy",
+    public readonly capturedContext?: RuntimeContext,
+  ) {
+    super();
+  }
+
+  public equals(other: YuValue): ExecutionCommand {
+    return boolean(other === this);
+  }
+  public compare(other: YuValue): ExecutionCommand {
+    return raise(error("LazyList.compare", "LazyLists are not comparable"));
+  }
+
+  get asSequence(): YuSequence {
+    return this;
+  }
+
+  public *[Symbol.iterator](): Iterator<YuValue> {
+    throw new Error(
+      "Cannot synchronously iterate a LazyList. Use realize() or step().",
+    );
+  }
+
+  /**
+   * Evaluates the first element of the list and returns it along with the tail.
+   */
+  public step(): ExecutionCommand {
+    if (this.memoized !== undefined) {
+      return new StepCommand(
+        this.memoized === null ? YuNil.getInstance() : this.memoized,
+      );
+    }
+
+    return new BindCommand(
+      this.producer(this.capturedContext),
+      (result: any) => {
+        if (
+          result === null ||
+          result === undefined ||
+          result instanceof YuNil
+        ) {
+          this.memoized = null;
+        } else if (result instanceof LazyStepResult) {
+          this.memoized = result;
+        } else if (result instanceof YuValue) {
+          this.memoized = new LazyStepResult(result, null);
+        } else {
+          // Fallback for raw JS values if any still exist
+          return raise(
+            error("LazyList.step", "LazyList producer returned non-YuValue"),
+          );
+        }
+        return new StepCommand(
+          this.memoized === null ? YuNil.getInstance() : this.memoized,
+        );
+      },
+    );
+  }
+
+  public size(): ExecutionCommand {
+    return raise(
+      error("[LazyList.size]", "Cannot calculate the length of a LazyList"),
+    );
+  }
+
+  public realize(): ExecutionCommand {
+    const result: YuValue[] = [];
+
+    const next = (list: Sequence): ExecutionCommand => {
+      return new BindCommand(list.step(), (stepRes) => {
+        if (stepRes instanceof YuNil)
+          return new StepCommand(new YuArray(result));
+
+        if (!(stepRes instanceof LazyStepResult))
+          return raise(
+            error(
+              "LazyList.realize",
+              "LazyList step did not return LazyStepResult",
+            ),
+          );
+
+        result.push(stepRes.head);
+        if (stepRes.tail) {
+          const tailSeq = stepRes.tail.asSequence;
+          if (tailSeq) return next(tailSeq);
+        }
+        return new StepCommand(new YuArray(result));
+      });
+    };
+    return next(this);
+  }
+
+  public concat(other: YuValue): ExecutionCommand {
+    const rightSeq = other.asSequence;
+    if (!rightSeq)
+      return raise(
+        error("LazyList.concat", "Cannot concatenate with a non-sequence"),
+      );
+    return new StepCommand(this.createLazyConcat(this, rightSeq));
+  }
+
+  public concatWithArray(arr: YuValue): ExecutionCommand {
+    const leftSeq = arr.asSequence;
+    if (!leftSeq) return raise(new NotConcatenable());
+
+    return new StepCommand(this.createLazyConcat(leftSeq, this));
+  }
+
+  public concatWithString(str: YuValue): ExecutionCommand {
+    const leftSeq = str.asSequence;
+    if (!leftSeq) return raise(new NotConcatenable());
+    return new StepCommand(this.createLazyConcat(leftSeq, this));
+  }
+
+  private createLazyConcat(left: YuSequence, right: YuSequence): LazyList {
+    return new LazyList(
+      (ctx) => {
+        // Step through the left sequence first
+        return new BindCommand(left.step(), (stepRes: YuValue) => {
+          // if left is exhausted, fallback immediately to stepping the right sequence
+          if (stepRes.isNil) return right.step();
+
+          // ensure we have a valid step result
+          const stepResult = stepRes.asStepResult;
+          if (!stepResult)
+            return raise(
+              error(
+                "LazyList.createLazyConcat",
+                "Invalid sequence step: Expected a StepResult",
+              ),
+            );
+
+          // recursively and lazily build the tail sequence
+          const nextTail =
+            stepResult.tail && !stepResult.tail.isNil
+              ? this.createLazyConcat(stepResult.tail, right)
+              : right;
+
+          return new StepCommand(new LazyStepResult(stepResult.head, nextTail));
+        });
+      },
+      `lazyConcat`,
+      this.capturedContext,
+    );
+  }
+
+  public toJSON() {
+    return {
+      identifier: this.identifier,
+      memoized:
+        this.memoized === undefined
+          ? "?"
+          : this.memoized === null
+            ? "[]"
+            : this.memoized.toJSON(),
+    };
+  }
+  public toString(): string {
+    const state =
+      this.memoized === undefined ? "?" : this.memoized === null ? "[]" : "...";
+    return `[LazyList ${this.identifier} ${state}]`;
+  }
+}
+
+export function isLazyList(prim: unknown): prim is LazyList {
+  return prim instanceof LazyList;
+}

package/src/interpreter/primitives/entities/LogicResult.ts

@@ -0,0 +1,133 @@
+import {
+  ExecutionCommand,
+  StepCommand,
+} from "../../components/kernel/commands.js";
+import { boolean, error, raise } from "../../utils.js";
+import { YuBoolean } from "../index.js";
+import { YuValue } from "../YuValue.js";
+
+/**
+ * Interface for logic terms that can be treated as runtime values.
+ */
+export abstract class LogicTerm extends YuValue {
+  abstract readonly logicTermType: string;
+  abstract unify(other: LogicTerm, env: Substitution): ExecutionCommand;
+  abstract resolve(env: Substitution): LogicTerm;
+  abstract instantiate(env: Substitution, seen?: Set<number>): LogicTerm;
+  abstract toPrimitive(env: Substitution): YuValue;
+  abstract occurs(v: any, env: Substitution): boolean;
+
+  public equals(other: YuValue): ExecutionCommand {
+    return boolean(this === other);
+  }
+
+  public compare(other: YuValue): ExecutionCommand {
+    return raise(
+      error(
+        "LogicTerm.compare",
+        `Comparison not supported for LogicTerm: ${this.logicTermType}`,
+      ),
+    );
+  }
+}
+
+export function isLogicTerm(val: unknown): val is LogicTerm {
+  return val !== null && typeof val === "object" && "logicTermType" in val;
+}
+
+/**
+ * Substitution map that supports numeric IDs (internally) and string names (for results).
+ */
+export type Substitution = Map<string | number, LogicTerm>;
+
+export class LogicAnswer extends YuValue {
+  private _success: boolean;
+  private _solution: Substitution;
+  constructor(success: boolean, solution: Substitution) {
+    super();
+    this._success = success;
+    this._solution = solution;
+  }
+  public equals(other: YuValue): ExecutionCommand {
+    return boolean(other === this);
+  }
+  public compare(other: YuValue): ExecutionCommand {
+    return raise(error("LogicAnswer.compare", "LogicAnswer is not comparable"));
+  }
+  public isSuccessful(): boolean {
+    return this._success;
+  }
+  public getSolution(): Substitution {
+    return this._solution;
+  }
+  public get success(): boolean {
+    return this.isSuccessful();
+  }
+  /**
+   * Returns a view of the solutions containing only string-named variables (for the user).
+   */
+  public get solutions(): Substitution {
+    return this._solution;
+  }
+
+  public toJSON(): unknown {
+    const sol: Record<string, unknown> = {};
+    for (const [key, val] of this._solution) {
+      if (typeof key === "string") sol[key] = val.toJSON();
+    }
+    return { success: this._success, solution: sol };
+  }
+  public toString(): string {
+    return `Answer(${this._success})`;
+  }
+}
+
+export class LogicResult extends YuValue {
+  private answers: LogicAnswer[];
+  constructor(answers: LogicAnswer[]) {
+    super();
+    this.answers = answers;
+  }
+  public equals(other: YuValue): ExecutionCommand {
+    return boolean(other === this);
+  }
+  public compare(other: YuValue): ExecutionCommand {
+    return raise(error("LogicResult.compare", "LogicResult is not comparable"));
+  }
+  public get allAnswers(): LogicAnswer[] {
+    return this.answers;
+  }
+  public getAllSuccessful(): LogicAnswer[] {
+    return this.answers.filter((answer) => answer.isSuccessful());
+  }
+  public allSuccessful(): boolean {
+    return (
+      this.answers.length > 0 &&
+      this.answers.every((answer) => answer.isSuccessful())
+    );
+  }
+  public getSuccessfulSolutions(): Substitution[] {
+    return this.getAllSuccessful().map((ans) => ans.getSolution());
+  }
+  public get success(): boolean {
+    return (
+      this.answers.length > 0 && this.answers.every((a) => a.isSuccessful())
+    );
+  }
+  public get solutions(): Substitution {
+    const answers = this.getAllSuccessful();
+    if (answers.length === 0) return new Map();
+    return answers[0].solutions;
+  }
+
+  public toJSON(): unknown {
+    return this.answers.map((a) => a.toJSON());
+  }
+  public toString(): string {
+    return `LogicResult(${this.answers.length})`;
+  }
+}
+
+export function isLogicResult(value: YuValue): value is LogicResult {
+  return value instanceof LogicResult;
+}