yukigo 0.2.3 → 0.3.2

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

@@ -0,0 +1,70 @@
+import {
+  ExecutionCommand,
+  StepCommand,
+} from "../../components/kernel/commands.js";
+import { InterpreterError } from "../../errors.js";
+import { boolean, error, raise } from "../../utils.js";
+import { YuBoolean } from "../index.js";
+import { YuValue } from "../YuValue.js";
+import { RuntimeFunction } from "./RuntimeFunction.js";
+import { RuntimeObject } from "./RuntimeObject.js";
+
+export class RuntimeClass extends YuValue {
+  constructor(
+    public identifier: string,
+    public fields: Map<string, YuValue>,
+    public methods: Map<string, RuntimeFunction>,
+    public mixins: string[],
+    public superclass?: string,
+    public fieldInitializers?: Map<string, any>,
+    private isAbstract: boolean = false,
+  ) {
+    super();
+  }
+
+  public equals(other: YuValue): ExecutionCommand {
+    return boolean(other === this);
+  }
+  public compare(other: YuValue): ExecutionCommand {
+    return raise(error("RuntimeClass.compare", "Classes are not comparable"));
+  }
+
+  public getHierarchy(): string[] {
+    const hierarchy = [...this.mixins.reverse()];
+    if (this.superclass) hierarchy.push(this.superclass);
+    return hierarchy;
+  }
+  /**
+   * Creates a new instance of an Object.
+   */
+  public instantiate(identifier: string): RuntimeObject {
+    if (this.isAbstract)
+      throw new InterpreterError(
+        "[ObjectRuntime]",
+        `Cannot instantiate abstract class ${this.identifier}`,
+      );
+    return new RuntimeObject(
+      identifier,
+      this.identifier,
+      new Map(this.fields),
+      new Map(),
+    );
+  }
+
+  public toJSON(): unknown {
+    return {
+      identifier: this.identifier,
+      superclass: this.superclass,
+      mixins: this.mixins,
+      isAbstract: this.isAbstract,
+    };
+  }
+
+  public toString(): string {
+    return `[Class: ${this.identifier}]`;
+  }
+}
+
+export function isRuntimeClass(val: YuValue): val is RuntimeClass {
+  return val instanceof RuntimeClass;
+}

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

@@ -0,0 +1,108 @@
+import { Body, Pattern } from "yukigo-ast";
+import { YuValue } from "../YuValue.js";
+import {
+  boolean,
+  EnvStack,
+  error,
+  PrimitiveThunk,
+  raise,
+} from "../../utils.js";
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+
+export interface EquationRuntime {
+  patterns: Pattern[];
+  body: Body;
+}
+/**
+ * Runtime Function used in the Interpreter
+ */
+export class RuntimeFunction extends YuValue {
+  constructor(
+    public arity: number,
+    public equations: EquationRuntime[],
+    public identifier?: string,
+    public pendingArgs?: (YuValue | PrimitiveThunk)[],
+    public closure?: EnvStack,
+  ) {
+    super();
+  }
+
+  public equals(other: YuValue): ExecutionCommand {
+    return boolean(other === this);
+  }
+  public compare(other: YuValue): ExecutionCommand {
+    return raise(
+      error("RuntimeFunction.compare", "Functions are not comparable"),
+    );
+  }
+
+  public get name(): string {
+    return this.identifier ?? "<anonymous>";
+  }
+
+  public get remainingArity(): number {
+    return this.arity - (this.pendingArgs?.length ?? 0);
+  }
+
+  public get isFullyApplied(): boolean {
+    return this.remainingArity <= 0;
+  }
+
+  public get hasPendingArgs(): boolean {
+    return (this.pendingArgs?.length ?? 0) > 0;
+  }
+
+  /**
+   * Partially applies the function with new arguments.
+   */
+  public bind(...args: (YuValue | PrimitiveThunk)[]): RuntimeFunction {
+    return new RuntimeFunction(
+      this.arity,
+      this.equations,
+      this.identifier,
+      [...(this.pendingArgs ?? []), ...args],
+      this.closure,
+    );
+  }
+
+  /**
+   * Returns a new RuntimeFunction with the given closure.
+   */
+  public withClosure(closure: EnvStack): RuntimeFunction {
+    return new RuntimeFunction(
+      this.arity,
+      this.equations,
+      this.identifier,
+      this.pendingArgs,
+      closure,
+    );
+  }
+
+  /**
+   * Evaluates all pending arguments (resolving thunks).
+   */
+  public getEvaluatedArgs(): YuValue[] {
+    return (this.pendingArgs ?? []).map((arg) =>
+      typeof arg === "function" ? arg() : arg,
+    );
+  }
+
+  public toJSON(): unknown {
+    return {
+      name: this.name,
+      arity: this.arity,
+      remainingArity: this.remainingArity,
+    };
+  }
+
+  public toString(): string {
+    const arityInfo = this.arity > 0 ? `/${this.arity}` : "";
+    const pendingInfo = this.hasPendingArgs
+      ? ` (applied ${this.pendingArgs!.length})`
+      : "";
+    return `[Function: ${this.name}${arityInfo}${pendingInfo}]`;
+  }
+}
+export function isRuntimeFunction(val: YuValue): val is RuntimeFunction {
+  return val instanceof RuntimeFunction;
+}

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

@@ -0,0 +1,110 @@
+import {
+  ExecutionCommand,
+  StepCommand,
+} from "../../components/kernel/commands.js";
+import { InterpreterError } from "../../errors.js";
+import { boolean, error, raise } from "../../utils.js";
+import { YuBoolean } from "../index.js";
+import { YuValue } from "../YuValue.js";
+import { RuntimeClass } from "./RuntimeClass.js";
+import { RuntimeFunction } from "./RuntimeFunction.js";
+
+type OOPMatch = {
+  method: RuntimeFunction;
+  holder: RuntimeObject | RuntimeClass;
+};
+
+export class RuntimeObject extends YuValue {
+  constructor(
+    public identifier: string,
+    public className: string,
+    public fields: Map<string, YuValue>,
+    public methods: Map<string, RuntimeFunction>,
+  ) {
+    super();
+  }
+
+  public equals(other: YuValue): ExecutionCommand {
+    return boolean(other === this);
+  }
+  public compare(other: YuValue): ExecutionCommand {
+    return raise(error("RuntimeClass.compare", "Objects are not comparable"));
+  }
+
+  public hasField(name: string): boolean {
+    return this.fields.has(name);
+  }
+
+  public getField(name: string): YuValue {
+    if (!this.hasField(name))
+      throw new InterpreterError(
+        "[ObjectRuntime]",
+        `Field '${name}' not found in ${this.className}`,
+      );
+    return this.fields.get(name)!;
+  }
+
+  public setField(name: string, value: YuValue): void {
+    if (!this.hasField(name))
+      throw new InterpreterError(
+        "[ObjectRuntime]",
+        `Cannot set unknown field '${name}'`,
+      );
+    this.fields.set(name, value);
+  }
+
+  public getMethod(name: string): RuntimeFunction {
+    if (!this.hasMethod(name))
+      throw new InterpreterError(
+        "[ObjectRuntime]",
+        `${this.className} does not understand '${name}`,
+      );
+    return this.methods.get(name)!;
+  }
+  public hasMethod(name: string): boolean {
+    return this.methods.has(name);
+  }
+  public createDispatchScope(match: OOPMatch, targetName: YuValue) {
+    const objectScope = new Map<string, YuValue>();
+
+    objectScope.set("self", this);
+    objectScope.set("__CONTEXT_CLASS__", match.holder);
+    objectScope.set("__METHOD_NAME__", targetName);
+    for (const [key, val] of this.fields) objectScope.set(key, val);
+
+    return objectScope;
+  }
+
+  public toJSON(keyOrSeen?: string | Set<YuValue>): unknown {
+    const seen = keyOrSeen instanceof Set ? keyOrSeen : new Set<YuValue>();
+    if (seen.has(this)) return { identifier: this.identifier, circular: true };
+    seen.add(this);
+    
+    const fieldsJSON: Record<string, unknown> = {};
+    for (const [key, val] of this.fields) fieldsJSON[key] = val.toJSON(seen);
+    
+    seen.delete(this);
+    return {
+      identifier: this.identifier,
+      className: this.className,
+      fields: fieldsJSON,
+    };
+  }
+
+  public toString(seen = new Set<YuValue>()): string {
+    if (seen.has(this)) return this.identifier || this.className || "object (circular)";
+    seen.add(this);
+
+    const fieldsArray: string[] = [];
+    for (const [k, v] of this.fields.entries()) {
+      fieldsArray.push(`${k}=${v ? v.toString(seen) : "nil"}`);
+    }
+    const name = this.identifier || this.className || "object";
+    seen.delete(this);
+    return `${name}[${fieldsArray.join(", ")}]`;
+  }
+}
+
+export function isRuntimeObject(val: YuValue): val is RuntimeObject {
+  return val instanceof RuntimeObject;
+}

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

@@ -0,0 +1,77 @@
+import { Fact, Rule, Visitor } from "yukigo-ast";
+import { InterpreterError } from "../../errors.js";
+import { YuValue } from "../YuValue.js";
+import {
+  ExecutionCommand,
+  StepCommand,
+} from "../../components/kernel/commands.js";
+import { YuBoolean } from "../index.js";
+import { boolean, error, raise } from "../../utils.js";
+
+export class RuntimePredicate extends YuValue {
+  public readonly arity: number;
+  constructor(
+    public identifier: string,
+    public equations: (Fact | Rule)[],
+  ) {
+    super();
+    if (equations.length === 0) {
+      throw new InterpreterError(
+        "RuntimePredicate",
+        `Predicate "${identifier}" must have at least one clause.`,
+      );
+    }
+    this.arity = this.getArityFromClause(equations[0]);
+  }
+
+  public equals(other: YuValue): ExecutionCommand {
+    return boolean(other === this);
+  }
+  public compare(other: YuValue): ExecutionCommand {
+    return raise(
+      error("RuntimePredicate.compare", "Predicates are not comparable"),
+    );
+  }
+
+  public apply<T>(visitor: Visitor<T>): T[] {
+    return this.equations.map((clause) => clause.accept(visitor));
+  }
+  public addClause(clause: Fact | Rule) {
+    const clauseArity = this.getArityFromClause(clause);
+    if (!this.validateClause(clause)) {
+      throw new InterpreterError(
+        "RuntimePredicate",
+        `Arity mismatch for "${this.identifier}": expected ${this.arity}, got ${clauseArity}.`,
+      );
+    }
+    this.equations.push(clause);
+  }
+  private validateClause(clause: Fact | Rule): boolean {
+    const clauseArity = this.getArityFromClause(clause);
+    return this.validateArity(clauseArity);
+  }
+  public validateArity(args: number): boolean {
+    return this.arity === args;
+  }
+  private getArityFromClause(clause: Fact | Rule): number {
+    if (clause.is(Fact)) return clause.patterns.length;
+    const patterns =
+      clause.equations.length > 0 ? clause.equations[0].patterns : [];
+    return patterns.length;
+  }
+
+  public toJSON(): unknown {
+    return {
+      identifier: this.identifier,
+      arity: this.arity,
+    };
+  }
+
+  public toString() {
+    return `[Predicate: ${this.identifier}/${this.arity}]`;
+  }
+}
+
+export const isRuntimePredicate = (prim: unknown): prim is RuntimePredicate => {
+  return prim instanceof RuntimePredicate;
+};

package/src/interpreter/primitives/index.ts

@@ -0,0 +1,17 @@
+export * from "./YuValue.js";
+export * from "./capabilities.js";
+
+export { YuBoolean } from "./scalars/YuBoolean.js";
+export { YuNil } from "./scalars/YuNil.js";
+export { YuNumber } from "./scalars/YuNumber.js";
+
+export { YuArray } from "./sequences/YuArray.js";
+export { YuChar } from "./scalars/YuChar.js";
+export { YuString } from "./sequences/YuString.js";
+
+export * from "./entities/LazyList.js";
+export * from "./entities/LogicResult.js";
+export * from "./entities/RuntimeClass.js";
+export * from "./entities/RuntimeFunction.js";
+export * from "./entities/RuntimeObject.js";
+export * from "./entities/RuntimePredicate.js";

package/src/interpreter/primitives/scalars/YuBoolean.ts

@@ -0,0 +1,79 @@
+import {
+  ExecutionCommand,
+  StepCommand,
+} from "../../components/kernel/commands.js";
+import { UnsupportedOperation } from "../../errors.js";
+import { boolean, raise } from "../../utils.js";
+import { Comparable, Logic, YuComparable, YuLogic } from "../capabilities.js";
+import { YuValue } from "../YuValue.js";
+import { YuNumber } from "./YuNumber.js";
+
+export class YuBoolean extends YuValue implements Logic, Comparable {
+  constructor(public readonly value: boolean) {
+    super();
+  }
+
+  get asLogic(): YuLogic {
+    return this;
+  }
+  get asComparable(): YuComparable {
+    return this;
+  }
+
+  public not(): ExecutionCommand {
+    return boolean(!this.value);
+  }
+
+  public equals(other: YuValue): ExecutionCommand {
+    const c = other.asComparable;
+    if (!c) return boolean(false);
+    return c.equalsWithBoolean(this);
+  }
+
+  public equalsWithNumber(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithBoolean(left: YuBoolean): ExecutionCommand {
+    return boolean(left.value === this.value);
+  }
+  public equalsWithString(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithArray(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithNil(): ExecutionCommand {
+    return boolean(false);
+  }
+
+  public compare(other: YuValue): ExecutionCommand {
+    const c = other.asComparable;
+    if (!c) return raise(new UnsupportedOperation(other, "compare"));
+    return c.compareWithBoolean(this);
+  }
+
+  public compareWithNumber(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+  public compareWithBoolean(left: YuBoolean): ExecutionCommand {
+    return new StepCommand(
+      new YuNumber((left.value ? 1 : 0) - (this.value ? 1 : 0)),
+    );
+  }
+  public compareWithString(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+  public compareWithArray(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+  public compareWithNil(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+
+  public toString(): string {
+    return this.value.toString();
+  }
+  public toJSON(): boolean {
+    return this.value;
+  }
+}

package/src/interpreter/primitives/scalars/YuChar.ts

@@ -0,0 +1,94 @@
+import {
+  ExecutionCommand,
+  StepCommand,
+} from "../../components/kernel/commands.js";
+import { UnsupportedOperation } from "../../errors.js";
+import { boolean, raise } from "../../utils.js";
+import {
+  Comparable,
+  Summable,
+  YuComparable,
+  YuSummable,
+} from "../capabilities.js";
+import { YuString } from "../sequences/YuString.js";
+import { YuValue } from "../YuValue.js";
+import { YuBoolean } from "./YuBoolean.js";
+import { YuNumber } from "./YuNumber.js";
+
+export class YuChar extends YuValue implements Comparable, Summable {
+  constructor(public readonly value: string) {
+    super();
+    if (value.length !== 1)
+      throw new Error("YuChar must be a single character");
+  }
+
+  get asSummable(): YuSummable {
+    return this;
+  }
+  get asComparable(): YuComparable {
+    return this;
+  }
+
+  public equals(other: YuValue): ExecutionCommand {
+    const c = other.asComparable;
+    if (!c) return boolean(false);
+    return c.equalsWithString(this);
+  }
+
+  public equalsWithNumber(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithBoolean(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithString(left: YuString): ExecutionCommand {
+    return boolean(left.toJSON() === this.value);
+  }
+  public equalsWithArray(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithNil(): ExecutionCommand {
+    return boolean(false);
+  }
+
+  public compare(other: YuValue): ExecutionCommand {
+    const c = other.asComparable;
+    if (!c) return raise(new UnsupportedOperation(other, "compare"));
+    return c.compareWithString(new YuString(this.value));
+  }
+
+  public compareWithNumber(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+  public compareWithBoolean(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+  public compareWithString(left: YuString): ExecutionCommand {
+    return new StepCommand(
+      new YuNumber(left.toJSON().localeCompare(this.value)),
+    );
+  }
+  public compareWithArray(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+  public compareWithNil(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+
+  public plus(other: YuValue): ExecutionCommand {
+    return new StepCommand(new YuString(this.value + other.toString()));
+  }
+  public plusWithNumber(left: YuNumber): ExecutionCommand {
+    return new StepCommand(new YuString(left.toJSON().toString() + this.value));
+  }
+  public plusWithString(left: YuString): ExecutionCommand {
+    return new StepCommand(new YuString(left.toJSON() + this.value));
+  }
+
+  public toString(): string {
+    return this.value;
+  }
+  public toJSON(): string {
+    return this.value;
+  }
+}

package/src/interpreter/primitives/scalars/YuNil.ts

@@ -0,0 +1,84 @@
+import {
+  ExecutionCommand,
+  StepCommand,
+} from "../../components/kernel/commands.js";
+import { UnsupportedOperation } from "../../errors.js";
+import { boolean, raise } from "../../utils.js";
+import { Comparable, YuComparable } from "../capabilities.js";
+import { YuValue } from "../YuValue.js";
+import { YuBoolean } from "./YuBoolean.js";
+import { YuNumber } from "./YuNumber.js";
+
+export class YuNil extends YuValue implements Comparable {
+  private static instance: YuNil;
+  private constructor() {
+    super();
+  }
+  public static getInstance(): YuNil {
+    if (!YuNil.instance) YuNil.instance = new YuNil();
+    return YuNil.instance;
+  }
+
+  get isNil(): boolean {
+    return true;
+  }
+
+  get asComparable(): YuComparable {
+    return this;
+  }
+
+  public equals(other: YuValue): ExecutionCommand {
+    const c = other.asComparable;
+    if (!c) return boolean(false);
+    return c.equalsWithNil(this);
+  }
+
+  public equalsWithNumber(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithBoolean(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithString(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithArray(): ExecutionCommand {
+    return boolean(false);
+  }
+  public equalsWithNil(left: YuNil): ExecutionCommand {
+    return boolean(true);
+  }
+
+  public compare(other: YuValue): ExecutionCommand {
+    const c = other.asComparable;
+    if (!c) return raise(new UnsupportedOperation(other, "compare"));
+    return c.compareWithNil(this);
+  }
+
+  public compareWithNumber(): ExecutionCommand {
+    return this.unsupportedCompare();
+  }
+  public compareWithBoolean(): ExecutionCommand {
+    return this.unsupportedCompare();
+  }
+  public compareWithString(): ExecutionCommand {
+    return this.unsupportedCompare();
+  }
+  public compareWithArray(): ExecutionCommand {
+    return this.unsupportedCompare();
+  }
+  public compareWithNil(): ExecutionCommand {
+    return new StepCommand(new YuNumber(0));
+  }
+
+  private unsupportedCompare(): ExecutionCommand {
+    return raise(new UnsupportedOperation(this, "compare"));
+  }
+
+  public toString(): string {
+    return "nil";
+  }
+  public toJSON(): null {
+    return null;
+  }
+}