yukigo 0.1.0 → 0.2.0

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

@@ -0,0 +1,224 @@
+import {
+  PrimitiveValue,
+  RuntimeFunction,
+  RuntimeObject,
+  isRuntimeObject,
+  isRuntimeClass,
+  RuntimeClass,
+  EnvStack,
+} from "yukigo-ast";
+import { InterpreterError } from "../../errors.js";
+import { Continuation, Thunk } from "../../trampoline.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+
+type OOPEntity = RuntimeClass | RuntimeObject;
+
+type OOPMatch = {
+  method: RuntimeFunction;
+  holder: RuntimeObject | RuntimeClass;
+};
+
+export class ObjectRuntime {
+  constructor(private context: RuntimeContext) {}
+  /**
+   * Creates a new instance of an Object.
+   * Typically called by visitNew()
+   */
+  public instantiate(
+    className: string,
+    identifier: string,
+    fieldDefinitions: Map<string, PrimitiveValue>,
+    methodDefinitions: Map<string, RuntimeFunction>,
+  ): RuntimeObject {
+    return {
+      type: "Object",
+      className,
+      identifier,
+      fields: new Map(fieldDefinitions),
+      methods: methodDefinitions,
+    };
+  }
+
+  /**
+   * Handles Method Calls (Message Passing).
+   * Reuses FunctionRuntime to execute the method body.
+   */
+  public dispatch(
+    receiver: PrimitiveValue,
+    methodName: string,
+    args: PrimitiveValue[],
+    env: EnvStack,
+    k: Continuation<PrimitiveValue>,
+  ): Thunk<PrimitiveValue> {
+    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);
+    this.context.pushEnv(objectScope);
+    return this.context.funcRuntime.apply(match.method, args, k);
+  }
+
+  /**
+   * Handles calls to super() or super.method()
+   */
+  public dispatchSuper(
+    currentEnv: EnvStack,
+    methodName: string,
+    args: PrimitiveValue[],
+    k: Continuation<PrimitiveValue>,
+  ): Thunk<PrimitiveValue> {
+    const self = this.context.lookup("self") as RuntimeObject;
+    const currentHolder = this.context.lookup("__CONTEXT_CLASS__") as OOPEntity;
+    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);
+
+    const currentIndex = chain.findIndex((c) => c === currentHolder);
+
+    if (currentIndex === -1)
+      throw new Error("Fatal: Execution context not found in hierarchy chain");
+
+    const remainingChain = chain.slice(currentIndex + 1);
+    const match = this.findMethodInChain(remainingChain, methodName);
+
+    if (!match)
+      throw new InterpreterError(
+        "Super",
+        `Super method '${methodName}' not found`,
+      );
+
+    const objectScope = this.createDispatchScope(self, match, targetMethodName);
+
+    this.context.pushEnv(objectScope);
+    return this.context.funcRuntime.apply(match.method, args, k);
+  }
+  private createDispatchScope(
+    self: RuntimeObject,
+    match: OOPMatch,
+    targetName: PrimitiveValue,
+  ) {
+    const objectScope = new Map<string, PrimitiveValue>();
+    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;
+  }
+  private getResolutionChain(
+    receiver: RuntimeObject,
+    env: EnvStack,
+  ): Array<RuntimeObject | RuntimeClass> {
+    const chain: Array<RuntimeObject | RuntimeClass> = [];
+
+    chain.push(receiver);
+
+    if (receiver.className) {
+      this.expandClassHierarchy(receiver.className, env, chain);
+    }
+
+    return chain;
+  }
+  private expandClassHierarchy(
+    className: string,
+    env: EnvStack,
+    chain: Array<RuntimeObject | RuntimeClass>,
+  ) {
+    const classDef = this.context.lookup(className);
+    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);
+  }
+  private findMethodInChain(
+    chain: Array<RuntimeObject | RuntimeClass>,
+    methodName: string,
+  ): OOPMatch | undefined {
+    for (const link of chain) {
+      if (link.methods.has(methodName))
+        return {
+          method: link.methods.get(methodName)!,
+          holder: link,
+        };
+    }
+    return undefined;
+  }
+
+  /**
+   * Field Access (Get)
+   * e.g. self.myField
+   */
+  public getField(receiver: PrimitiveValue, fieldName: string): PrimitiveValue {
+    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);
+  }
+
+  /**
+   * Field Mutation (Set)
+   * e.g. self.myField = 10
+   */
+  public setField(
+    receiver: PrimitiveValue,
+    fieldName: string,
+    value: PrimitiveValue,
+  ): PrimitiveValue {
+    if (!this.context.config.mutability)
+      throw new InterpreterError(
+        "FieldAssignment",
+        `Cannot mutate field '${fieldName}': mutability is disabled`,
+      );
+
+    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;
+  }
+}

package/src/interpreter/errors.ts

@@ -1,47 +1,47 @@
-import { SourceLocation } from "yukigo-ast";
-
-export interface ErrorFrame {
-  nodeType: string;
-  loc?: SourceLocation;
-}
-
-export class InterpreterError extends Error {
-  context: string;
-  frames: ErrorFrame[];
-
-  constructor(context: string, message: string, frames: ErrorFrame[] = []) {
-    super(`[${context}] ${message}`);
-    this.context = context;
-    this.frames = frames;
-  }
-
-  pushFrame(frame: ErrorFrame) {
-    this.frames.push(frame);
-  }
-
-  formatStack(): string {
-    if (!this.frames.length) return "";
-    const formatted = this.frames
-      .map((f) => {
-        const loc = f.loc ? ` (line ${f.loc.line}, col ${f.loc.column})` : "";
-        return `  • ${f.nodeType}${loc}`;
-      })
-      .join("\n");
-    return `\nTrace:\n${formatted}`;
-  }
-
-  override toString(): string {
-    return `${this.message}${this.formatStack()}`;
-  }
-}
-export class UnexpectedValue extends InterpreterError {
-  constructor(ctx: string, expected: string, got: string) {
-    super(ctx, `Expected ${expected} but got ${got}`);
-  }
-}
-
-export class UnboundVariable extends Error {
-  constructor(name: string) {
-    super(`Unbound variable: ${name}`);
-  }
-}
+import { SourceLocation } from "yukigo-ast";
+
+export interface ErrorFrame {
+  nodeType: string;
+  loc?: SourceLocation;
+}
+
+export class InterpreterError extends Error {
+  context: string;
+  frames: ErrorFrame[];
+
+  constructor(context: string, message: string, frames: ErrorFrame[] = []) {
+    super(`[${context}] ${message}`);
+    this.context = context;
+    this.frames = frames;
+  }
+
+  pushFrame(frame: ErrorFrame) {
+    this.frames.push(frame);
+  }
+
+  formatStack(): string {
+    if (!this.frames.length) return "";
+    const formatted = this.frames
+      .map((f) => {
+        const loc = f.loc ? ` (line ${f.loc.line}, col ${f.loc.column})` : "";
+        return `  • ${f.nodeType}${loc}`;
+      })
+      .join("\n");
+    return `\nTrace:\n${formatted}`;
+  }
+
+  override toString(): string {
+    return `${this.message}${this.formatStack()}`;
+  }
+}
+export class UnexpectedValue extends InterpreterError {
+  constructor(ctx: string, expected: string, got: string) {
+    super(ctx, `Expected ${expected} but got ${got}`);
+  }
+}
+
+export class UnboundVariable extends Error {
+  constructor(name: string) {
+    super(`Unbound variable: ${name}`);
+  }
+}

package/src/interpreter/index.ts

@@ -1,59 +1,52 @@
-import { PrimitiveValue, Expression, AST } from "yukigo-ast";
-import { InterpreterVisitor } from "./components/Visitor.js";
-import { EnvBuilderVisitor } from "./components/EnvBuilder.js";
-import { InterpreterError } from "./errors.js";
-
-export type Bindings = [string, PrimitiveValue][];
-
-export type LogicSearchMode = "first" | "all" | "stream";
-export type InterpreterConfig = {
-  lazyLoading?: boolean;
-  debug?: boolean;
-  outputMode?: LogicSearchMode;
-};
-
-export type Environment = Map<string, PrimitiveValue>;
-export type EnvStack = Environment[];
-
-const DefaultConfiguration: Required<InterpreterConfig> = {
-  lazyLoading: false,
-  debug: false,
-  outputMode: "first",
-};
-
-/**
- * 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 globalEnv: EnvStack;
-  private readonly config: InterpreterConfig;
-
-  /**
-   * @param ast The Abstract Syntax Tree (AST) of the program to be interpreted.
-   */
-  constructor(ast: AST, config?: InterpreterConfig) {
-    this.globalEnv = new EnvBuilderVisitor().build(ast);
-    this.config = config ?? DefaultConfiguration;
-  }
-
-  /**
-   * 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: Expression): PrimitiveValue {
-    try {
-      const visitor = new InterpreterVisitor(this.globalEnv, this.config);
-      const evaluatedExpr = expr.accept(visitor);
-      return evaluatedExpr;
-    } catch (error) {
-      if (error instanceof InterpreterError) console.log(error.formatStack());
-      throw error;
-    }
-  }
-}
+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;
+    }
+  }
+}

package/src/interpreter/trampoline.ts

@@ -0,0 +1,71 @@
+import { PrimitiveValue } from "yukigo-ast";
+
+// A Thunk now represents a deferred computation that, when called,
+// will produce either a value or another thunk.
+// Importantly, for our visitor, the Thunk will wrap the *decision* of what to do next.
+// A node's evaluation might return a function that *takes* the continuation for that node.
+export type CallableThunk<T> = () => Thunk<T>;
+export type Thunk<T> = T | CallableThunk<T>;
+
+const isCallableThunk = <T>(thunk: Thunk<T>): thunk is CallableThunk<T> =>
+  typeof thunk === "function";
+
+// A Continuation is a function that takes a value and returns a Thunk,
+// representing the "rest of the computation" after the value is produced.
+export type Continuation<T, R = any> = (value: T) => Thunk<R>;
+
+// The identity continuation: simply returns the value as a resolved Thunk.
+// This is used for the very last step of a computation or when a value is final.
+export const idContinuation: Continuation<PrimitiveValue> = (value) => value;
+
+// The trampoline function executes a chain of Thunks until a final non-function value is reached.
+export function trampoline<T>(thunk: Thunk<T>): T {
+  let result = thunk;
+  while (isCallableThunk(result)) result = result();
+  return result;
+}
+
+/**
+ * A specialized Thunk type for our CPS visitor.
+ * This is a function that, when called, takes the continuation for the current node's evaluation
+ * and returns the actual Thunk chain for that node.
+ * This effectively injects the continuation *after* the `visit` method has returned.
+ */
+export type CPSThunk<T, R = any> = (k: Continuation<T, R>) => Thunk<R>;
+
+// Helper to create a CPSThunk for visitor methods.
+// Visitor methods will call this, providing a function that knows how to use 'k'.
+export function makeCPSThunk<T>(
+  fn: (k: Continuation<T>) => Thunk<T>,
+): CPSThunk<T> {
+  return fn;
+}
+
+// Helper to compose asynchronous/CPS operations.
+// `cpsA` is a CPSThunk that eventually produces a value A.
+// `f` is a function that takes A and returns a CPSThunk that eventually produces B.
+export function bindCPS<A, B, R>(
+  cpsA: CPSThunk<A, R>,
+  f: (valueA: A) => CPSThunk<B, R>,
+): CPSThunk<B, R> {
+  return (k: Continuation<B, R>): Thunk<R> => {
+    return () =>
+      cpsA((valueA: A): Thunk<R> => {
+        // f(valueA) returns a CPSThunk<B, R>
+        // calling that with 'k' returns Thunk<R>
+        return f(valueA)(k);
+      });
+  };
+}
+
+// Helper to lift a direct value into a CPSThunk
+export function valueToCPS<T, R>(value: T): CPSThunk<T, R> {
+  return (k: Continuation<T, R>) => () => k(value);
+}
+
+// Helper to lift a regular Thunk into a CPSThunk (if it resolves a simple Thunk)
+export function thunkToCPS<T>(thunk: Thunk<T>): CPSThunk<T> {
+  return (k: Continuation<T>) => {
+    return () => k(trampoline(thunk)); // Trampoline the simple thunk and pass its result to k
+  };
+}

package/src/interpreter/utils.ts

@@ -1,79 +1,84 @@
-import { Expression, LazyList, PrimitiveValue } from "yukigo-ast";
-import { Environment, EnvStack } from "./index.js";
-import { UnboundVariable } from "./errors.js";
-
-export interface ExpressionEvaluator {
-  evaluate(node: Expression): PrimitiveValue;
-}
-
-export function createStream(
-  generator: () => Generator<PrimitiveValue, void, unknown>
-): LazyList {
-  return {
-    type: "LazyList",
-    generator,
-  };
-}
-
-export function isArrayOfNumbers(arr: PrimitiveValue[]): arr is number[] {
-  for (const item of arr) if (typeof item !== "number") return false;
-  return true;
-}
-
-export function generateRange(
-  start: number,
-  end: number,
-  step: number
-): number[] {
-  if (step === 0) throw new Error("Step cannot be zero in range expression");
-
-  const result: number[] = [];
-  let current = start;
-
-  if (step > 0) {
-    while (current <= end) {
-      result.push(current);
-      current += step;
-    }
-  } else {
-    while (current >= end) {
-      result.push(current);
-      current += step;
-    }
-  }
-
-  return result;
-}
-
-export function createEnv(bindings: [string, PrimitiveValue][]): Environment {
-  const env = new Map();
-  for (const [name, value] of bindings) env.set(name, value);
-  return env;
-}
-
-export function createGlobalEnv(): EnvStack {
-  return [new Map<string, PrimitiveValue>()];
-}
-
-export function pushEnv(env: EnvStack, frame?: Environment): EnvStack {
-  return [frame ?? new Map(), ...env];
-}
-
-export function popEnv(env: EnvStack): EnvStack {
-  return env.slice(1);
-}
-
-export function lookup(env: EnvStack, name: string): PrimitiveValue {
-  for (const frame of env) {
-    if (frame.has(name)) return frame.get(name);
-  }
-  throw new UnboundVariable(name);
-}
-
-export function define(
-  env: EnvStack,
-  name: string,
-  value: PrimitiveValue
-): void {
-  env[0].set(name, value);
-}
+import {
+  Expression,
+  LazyList,
+  PrimitiveValue,
+  Environment,
+  EnvStack,
+  ASTNode,
+  isRuntimeFunction,
+  isRuntimeObject,
+  isLazyList,
+  isRuntimeClass,
+  isRuntimePredicate,
+} from "yukigo-ast";
+import { UnboundVariable } from "./errors.js";
+import { Continuation, Thunk } from "./trampoline.js";
+
+export interface ExpressionEvaluator {
+  evaluate<R = PrimitiveValue>(node: ASTNode, cont: Continuation<PrimitiveValue, R>): Thunk<R>;
+}
+
+export function createStream(
+  generator: () => Generator<PrimitiveValue, void, unknown>,
+): LazyList {
+  return {
+    type: "LazyList",
+    generator,
+  };
+}
+
+export function isArrayOfNumbers(arr: PrimitiveValue[]): arr is number[] {
+  for (const item of arr) if (typeof item !== "number") return false;
+  return true;
+}
+
+export function generateRange(
+  start: number,
+  end: number,
+  step: number,
+): number[] {
+  if (step === 0) throw new Error("Step cannot be zero in range expression");
+
+  const result: number[] = [];
+  let current = start;
+
+  if (step > 0) {
+    while (current <= end) {
+      result.push(current);
+      current += step;
+    }
+  } else {
+    while (current >= end) {
+      result.push(current);
+      current += step;
+    }
+  }
+
+  return result;
+}
+
+export function createEnv(bindings: [string, PrimitiveValue][]): Environment {
+  const env = new Map();
+  for (const [name, value] of bindings) env.set(name, value);
+  return env;
+}
+
+export function createGlobalEnv(): EnvStack {
+  return {
+    head: new Map<string, PrimitiveValue>(),
+    tail: null,
+  };
+}
+
+export function getYukigoType(val: PrimitiveValue): string {
+  if (val === null || val === undefined) return "YuNil";
+  if (typeof val === "number") return "YuNumber";
+  if (typeof val === "boolean") return "YuBoolean";
+  if (typeof val === "string") return val.length === 1 ? "YuChar" : "YuString";
+  if (Array.isArray(val) || isLazyList(val)) return "YuList";
+  if (isRuntimeFunction(val)) return "YuFunction";
+  if (isRuntimeObject(val)) return "YuObject";
+  if (isRuntimeClass(val)) return "YuClass";
+  if (isRuntimePredicate(val)) return "YuPredicate";
+  return "YuUnknown";
+}