yukigo 0.2.2 → 0.3.1

package/dist/interpreter/primitives/entities/LazyList.js

@@ -0,0 +1,164 @@
+import { StepCommand, BindCommand, } from "../../components/kernel/commands.js";
+import { NotConcatenable } from "../../errors.js";
+import { boolean, error, raise } from "../../utils.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 {
+    head;
+    tail;
+    constructor(head, tail) {
+        super();
+        this.head = head;
+        this.tail = tail;
+    }
+    get asStepResult() {
+        return this;
+    }
+    equals(other) {
+        return boolean(other === this);
+    }
+    compare(other) {
+        return raise(error("LazyStepResult", "Step results are not comparable"));
+    }
+    toString() {
+        return `StepResult(${this.head}, ${this.tail})`;
+    }
+    toJSON() {
+        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 {
+    producer;
+    identifier;
+    capturedContext;
+    // Use 'undefined' for un-evaluated, 'null' for empty list.
+    memoized = undefined;
+    constructor(producer, identifier = "lazy", capturedContext) {
+        super();
+        this.producer = producer;
+        this.identifier = identifier;
+        this.capturedContext = capturedContext;
+    }
+    equals(other) {
+        return boolean(other === this);
+    }
+    compare(other) {
+        return raise(error("LazyList.compare", "LazyLists are not comparable"));
+    }
+    get asSequence() {
+        return this;
+    }
+    *[Symbol.iterator]() {
+        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.
+     */
+    step() {
+        if (this.memoized !== undefined) {
+            return new StepCommand(this.memoized === null ? YuNil.getInstance() : this.memoized);
+        }
+        return new BindCommand(this.producer(this.capturedContext), (result) => {
+            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);
+        });
+    }
+    size() {
+        return raise(error("[LazyList.size]", "Cannot calculate the length of a LazyList"));
+    }
+    realize() {
+        const result = [];
+        const next = (list) => {
+            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);
+    }
+    concat(other) {
+        const rightSeq = other.asSequence;
+        if (!rightSeq)
+            return raise(error("LazyList.concat", "Cannot concatenate with a non-sequence"));
+        return new StepCommand(this.createLazyConcat(this, rightSeq));
+    }
+    concatWithArray(arr) {
+        const leftSeq = arr.asSequence;
+        if (!leftSeq)
+            return raise(new NotConcatenable());
+        return new StepCommand(this.createLazyConcat(leftSeq, this));
+    }
+    concatWithString(str) {
+        const leftSeq = str.asSequence;
+        if (!leftSeq)
+            return raise(new NotConcatenable());
+        return new StepCommand(this.createLazyConcat(leftSeq, this));
+    }
+    createLazyConcat(left, right) {
+        return new LazyList((ctx) => {
+            // Step through the left sequence first
+            return new BindCommand(left.step(), (stepRes) => {
+                // 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);
+    }
+    toJSON() {
+        return {
+            identifier: this.identifier,
+            memoized: this.memoized === undefined
+                ? "?"
+                : this.memoized === null
+                    ? "[]"
+                    : this.memoized.toJSON(),
+        };
+    }
+    toString() {
+        const state = this.memoized === undefined ? "?" : this.memoized === null ? "[]" : "...";
+        return `[LazyList ${this.identifier} ${state}]`;
+    }
+}
+export function isLazyList(prim) {
+    return prim instanceof LazyList;
+}

package/dist/interpreter/primitives/entities/LogicResult.d.ts

@@ -0,0 +1,51 @@
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+import { YuValue } from "../YuValue.js";
+/**
+ * Interface for logic terms that can be treated as runtime values.
+ */
+export declare 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;
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+}
+export declare function isLogicTerm(val: unknown): val is LogicTerm;
+/**
+ * Substitution map that supports numeric IDs (internally) and string names (for results).
+ */
+export type Substitution = Map<string | number, LogicTerm>;
+export declare class LogicAnswer extends YuValue {
+    private _success;
+    private _solution;
+    constructor(success: boolean, solution: Substitution);
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    isSuccessful(): boolean;
+    getSolution(): Substitution;
+    get success(): boolean;
+    /**
+     * Returns a view of the solutions containing only string-named variables (for the user).
+     */
+    get solutions(): Substitution;
+    toJSON(): unknown;
+    toString(): string;
+}
+export declare class LogicResult extends YuValue {
+    private answers;
+    constructor(answers: LogicAnswer[]);
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    get allAnswers(): LogicAnswer[];
+    getAllSuccessful(): LogicAnswer[];
+    allSuccessful(): boolean;
+    getSuccessfulSolutions(): Substitution[];
+    get success(): boolean;
+    get solutions(): Substitution;
+    toJSON(): unknown;
+    toString(): string;
+}
+export declare function isLogicResult(value: YuValue): value is LogicResult;

package/dist/interpreter/primitives/entities/LogicResult.js

@@ -0,0 +1,101 @@
+import { boolean, error, raise } from "../../utils.js";
+import { YuValue } from "../YuValue.js";
+/**
+ * Interface for logic terms that can be treated as runtime values.
+ */
+export class LogicTerm extends YuValue {
+    equals(other) {
+        return boolean(this === other);
+    }
+    compare(other) {
+        return raise(error("LogicTerm.compare", `Comparison not supported for LogicTerm: ${this.logicTermType}`));
+    }
+}
+export function isLogicTerm(val) {
+    return val !== null && typeof val === "object" && "logicTermType" in val;
+}
+export class LogicAnswer extends YuValue {
+    _success;
+    _solution;
+    constructor(success, solution) {
+        super();
+        this._success = success;
+        this._solution = solution;
+    }
+    equals(other) {
+        return boolean(other === this);
+    }
+    compare(other) {
+        return raise(error("LogicAnswer.compare", "LogicAnswer is not comparable"));
+    }
+    isSuccessful() {
+        return this._success;
+    }
+    getSolution() {
+        return this._solution;
+    }
+    get success() {
+        return this.isSuccessful();
+    }
+    /**
+     * Returns a view of the solutions containing only string-named variables (for the user).
+     */
+    get solutions() {
+        return this._solution;
+    }
+    toJSON() {
+        const sol = {};
+        for (const [key, val] of this._solution) {
+            if (typeof key === "string")
+                sol[key] = val.toJSON();
+        }
+        return { success: this._success, solution: sol };
+    }
+    toString() {
+        return `Answer(${this._success})`;
+    }
+}
+export class LogicResult extends YuValue {
+    answers;
+    constructor(answers) {
+        super();
+        this.answers = answers;
+    }
+    equals(other) {
+        return boolean(other === this);
+    }
+    compare(other) {
+        return raise(error("LogicResult.compare", "LogicResult is not comparable"));
+    }
+    get allAnswers() {
+        return this.answers;
+    }
+    getAllSuccessful() {
+        return this.answers.filter((answer) => answer.isSuccessful());
+    }
+    allSuccessful() {
+        return (this.answers.length > 0 &&
+            this.answers.every((answer) => answer.isSuccessful()));
+    }
+    getSuccessfulSolutions() {
+        return this.getAllSuccessful().map((ans) => ans.getSolution());
+    }
+    get success() {
+        return (this.answers.length > 0 && this.answers.every((a) => a.isSuccessful()));
+    }
+    get solutions() {
+        const answers = this.getAllSuccessful();
+        if (answers.length === 0)
+            return new Map();
+        return answers[0].solutions;
+    }
+    toJSON() {
+        return this.answers.map((a) => a.toJSON());
+    }
+    toString() {
+        return `LogicResult(${this.answers.length})`;
+    }
+}
+export function isLogicResult(value) {
+    return value instanceof LogicResult;
+}

package/dist/interpreter/primitives/entities/RuntimeClass.d.ts

@@ -0,0 +1,24 @@
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+import { YuValue } from "../YuValue.js";
+import { RuntimeFunction } from "./RuntimeFunction.js";
+import { RuntimeObject } from "./RuntimeObject.js";
+export declare class RuntimeClass extends YuValue {
+    identifier: string;
+    fields: Map<string, YuValue>;
+    methods: Map<string, RuntimeFunction>;
+    mixins: string[];
+    superclass?: string | undefined;
+    fieldInitializers?: Map<string, any> | undefined;
+    private isAbstract;
+    constructor(identifier: string, fields: Map<string, YuValue>, methods: Map<string, RuntimeFunction>, mixins: string[], superclass?: string | undefined, fieldInitializers?: Map<string, any> | undefined, isAbstract?: boolean);
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    getHierarchy(): string[];
+    /**
+     * Creates a new instance of an Object.
+     */
+    instantiate(identifier: string): RuntimeObject;
+    toJSON(): unknown;
+    toString(): string;
+}
+export declare function isRuntimeClass(val: YuValue): val is RuntimeClass;

package/dist/interpreter/primitives/entities/RuntimeClass.js

@@ -0,0 +1,57 @@
+import { InterpreterError } from "../../errors.js";
+import { boolean, error, raise } from "../../utils.js";
+import { YuValue } from "../YuValue.js";
+import { RuntimeObject } from "./RuntimeObject.js";
+export class RuntimeClass extends YuValue {
+    identifier;
+    fields;
+    methods;
+    mixins;
+    superclass;
+    fieldInitializers;
+    isAbstract;
+    constructor(identifier, fields, methods, mixins, superclass, fieldInitializers, isAbstract = false) {
+        super();
+        this.identifier = identifier;
+        this.fields = fields;
+        this.methods = methods;
+        this.mixins = mixins;
+        this.superclass = superclass;
+        this.fieldInitializers = fieldInitializers;
+        this.isAbstract = isAbstract;
+    }
+    equals(other) {
+        return boolean(other === this);
+    }
+    compare(other) {
+        return raise(error("RuntimeClass.compare", "Classes are not comparable"));
+    }
+    getHierarchy() {
+        const hierarchy = [...this.mixins.reverse()];
+        if (this.superclass)
+            hierarchy.push(this.superclass);
+        return hierarchy;
+    }
+    /**
+     * Creates a new instance of an Object.
+     */
+    instantiate(identifier) {
+        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());
+    }
+    toJSON() {
+        return {
+            identifier: this.identifier,
+            superclass: this.superclass,
+            mixins: this.mixins,
+            isAbstract: this.isAbstract,
+        };
+    }
+    toString() {
+        return `[Class: ${this.identifier}]`;
+    }
+}
+export function isRuntimeClass(val) {
+    return val instanceof RuntimeClass;
+}

package/dist/interpreter/primitives/entities/RuntimeFunction.d.ts

@@ -0,0 +1,40 @@
+import { Body, Pattern } from "yukigo-ast";
+import { YuValue } from "../YuValue.js";
+import { EnvStack, PrimitiveThunk } from "../../utils.js";
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+export interface EquationRuntime {
+    patterns: Pattern[];
+    body: Body;
+}
+/**
+ * Runtime Function used in the Interpreter
+ */
+export declare class RuntimeFunction extends YuValue {
+    arity: number;
+    equations: EquationRuntime[];
+    identifier?: string | undefined;
+    pendingArgs?: (YuValue | PrimitiveThunk)[] | undefined;
+    closure?: EnvStack | undefined;
+    constructor(arity: number, equations: EquationRuntime[], identifier?: string | undefined, pendingArgs?: (YuValue | PrimitiveThunk)[] | undefined, closure?: EnvStack | undefined);
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    get name(): string;
+    get remainingArity(): number;
+    get isFullyApplied(): boolean;
+    get hasPendingArgs(): boolean;
+    /**
+     * Partially applies the function with new arguments.
+     */
+    bind(...args: (YuValue | PrimitiveThunk)[]): RuntimeFunction;
+    /**
+     * Returns a new RuntimeFunction with the given closure.
+     */
+    withClosure(closure: EnvStack): RuntimeFunction;
+    /**
+     * Evaluates all pending arguments (resolving thunks).
+     */
+    getEvaluatedArgs(): YuValue[];
+    toJSON(): unknown;
+    toString(): string;
+}
+export declare function isRuntimeFunction(val: YuValue): val is RuntimeFunction;

package/dist/interpreter/primitives/entities/RuntimeFunction.js

@@ -0,0 +1,73 @@
+import { YuValue } from "../YuValue.js";
+import { boolean, error, raise, } from "../../utils.js";
+/**
+ * Runtime Function used in the Interpreter
+ */
+export class RuntimeFunction extends YuValue {
+    arity;
+    equations;
+    identifier;
+    pendingArgs;
+    closure;
+    constructor(arity, equations, identifier, pendingArgs, closure) {
+        super();
+        this.arity = arity;
+        this.equations = equations;
+        this.identifier = identifier;
+        this.pendingArgs = pendingArgs;
+        this.closure = closure;
+    }
+    equals(other) {
+        return boolean(other === this);
+    }
+    compare(other) {
+        return raise(error("RuntimeFunction.compare", "Functions are not comparable"));
+    }
+    get name() {
+        return this.identifier ?? "<anonymous>";
+    }
+    get remainingArity() {
+        return this.arity - (this.pendingArgs?.length ?? 0);
+    }
+    get isFullyApplied() {
+        return this.remainingArity <= 0;
+    }
+    get hasPendingArgs() {
+        return (this.pendingArgs?.length ?? 0) > 0;
+    }
+    /**
+     * Partially applies the function with new arguments.
+     */
+    bind(...args) {
+        return new RuntimeFunction(this.arity, this.equations, this.identifier, [...(this.pendingArgs ?? []), ...args], this.closure);
+    }
+    /**
+     * Returns a new RuntimeFunction with the given closure.
+     */
+    withClosure(closure) {
+        return new RuntimeFunction(this.arity, this.equations, this.identifier, this.pendingArgs, closure);
+    }
+    /**
+     * Evaluates all pending arguments (resolving thunks).
+     */
+    getEvaluatedArgs() {
+        return (this.pendingArgs ?? []).map((arg) => typeof arg === "function" ? arg() : arg);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            arity: this.arity,
+            remainingArity: this.remainingArity,
+        };
+    }
+    toString() {
+        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) {
+    return val instanceof RuntimeFunction;
+}

package/dist/interpreter/primitives/entities/RuntimeObject.d.ts

@@ -0,0 +1,27 @@
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+import { YuValue } from "../YuValue.js";
+import { RuntimeClass } from "./RuntimeClass.js";
+import { RuntimeFunction } from "./RuntimeFunction.js";
+type OOPMatch = {
+    method: RuntimeFunction;
+    holder: RuntimeObject | RuntimeClass;
+};
+export declare class RuntimeObject extends YuValue {
+    identifier: string;
+    className: string;
+    fields: Map<string, YuValue>;
+    methods: Map<string, RuntimeFunction>;
+    constructor(identifier: string, className: string, fields: Map<string, YuValue>, methods: Map<string, RuntimeFunction>);
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    hasField(name: string): boolean;
+    getField(name: string): YuValue;
+    setField(name: string, value: YuValue): void;
+    getMethod(name: string): RuntimeFunction;
+    hasMethod(name: string): boolean;
+    createDispatchScope(match: OOPMatch, targetName: YuValue): Map<string, YuValue>;
+    toJSON(keyOrSeen?: string | Set<YuValue>): unknown;
+    toString(seen?: Set<YuValue>): string;
+}
+export declare function isRuntimeObject(val: YuValue): val is RuntimeObject;
+export {};

package/dist/interpreter/primitives/entities/RuntimeObject.js

@@ -0,0 +1,82 @@
+import { InterpreterError } from "../../errors.js";
+import { boolean, error, raise } from "../../utils.js";
+import { YuValue } from "../YuValue.js";
+export class RuntimeObject extends YuValue {
+    identifier;
+    className;
+    fields;
+    methods;
+    constructor(identifier, className, fields, methods) {
+        super();
+        this.identifier = identifier;
+        this.className = className;
+        this.fields = fields;
+        this.methods = methods;
+    }
+    equals(other) {
+        return boolean(other === this);
+    }
+    compare(other) {
+        return raise(error("RuntimeClass.compare", "Objects are not comparable"));
+    }
+    hasField(name) {
+        return this.fields.has(name);
+    }
+    getField(name) {
+        if (!this.hasField(name))
+            throw new InterpreterError("[ObjectRuntime]", `Field '${name}' not found in ${this.className}`);
+        return this.fields.get(name);
+    }
+    setField(name, value) {
+        if (!this.hasField(name))
+            throw new InterpreterError("[ObjectRuntime]", `Cannot set unknown field '${name}'`);
+        this.fields.set(name, value);
+    }
+    getMethod(name) {
+        if (!this.hasMethod(name))
+            throw new InterpreterError("[ObjectRuntime]", `${this.className} does not understand '${name}`);
+        return this.methods.get(name);
+    }
+    hasMethod(name) {
+        return this.methods.has(name);
+    }
+    createDispatchScope(match, targetName) {
+        const objectScope = new Map();
+        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;
+    }
+    toJSON(keyOrSeen) {
+        const seen = keyOrSeen instanceof Set ? keyOrSeen : new Set();
+        if (seen.has(this))
+            return { identifier: this.identifier, circular: true };
+        seen.add(this);
+        const fieldsJSON = {};
+        for (const [key, val] of this.fields)
+            fieldsJSON[key] = val.toJSON(seen);
+        seen.delete(this);
+        return {
+            identifier: this.identifier,
+            className: this.className,
+            fields: fieldsJSON,
+        };
+    }
+    toString(seen = new Set()) {
+        if (seen.has(this))
+            return this.identifier || this.className || "object (circular)";
+        seen.add(this);
+        const fieldsArray = [];
+        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) {
+    return val instanceof RuntimeObject;
+}

package/dist/interpreter/primitives/entities/RuntimePredicate.d.ts

@@ -0,0 +1,19 @@
+import { Fact, Rule, Visitor } from "yukigo-ast";
+import { YuValue } from "../YuValue.js";
+import { ExecutionCommand } from "../../components/kernel/commands.js";
+export declare class RuntimePredicate extends YuValue {
+    identifier: string;
+    equations: (Fact | Rule)[];
+    readonly arity: number;
+    constructor(identifier: string, equations: (Fact | Rule)[]);
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    apply<T>(visitor: Visitor<T>): T[];
+    addClause(clause: Fact | Rule): void;
+    private validateClause;
+    validateArity(args: number): boolean;
+    private getArityFromClause;
+    toJSON(): unknown;
+    toString(): string;
+}
+export declare const isRuntimePredicate: (prim: unknown) => prim is RuntimePredicate;