yukigo 0.2.3 → 0.3.2

package/dist/interpreter/components/logic/LogicTerm.js

@@ -0,0 +1,423 @@
+import { YuString, YuNumber, YuNil, RuntimeObject, YuArray, YuBoolean, } from "../../primitives/index.js";
+import { boolean, error, raise } from "../../utils.js";
+import { StepCommand, BindCommand, } from "../kernel/commands.js";
+import { LogicTerm, } from "../../primitives/entities/LogicResult.js";
+function unifyArray(arr1, arr2, env) {
+    const next = (index) => {
+        if (index >= arr1.length)
+            return boolean(true);
+        return new BindCommand(arr1[index].unify(arr2[index], env), (res) => {
+            if (res instanceof YuBoolean && res.value) {
+                return next(index + 1);
+            }
+            return boolean(false);
+        });
+    };
+    return next(0);
+}
+/**
+ * Represents a logic variable with a unique numeric ID.
+ */
+export class VariableTerm extends LogicTerm {
+    id;
+    name;
+    logicTermType = "Variable";
+    constructor(id, name) {
+        super();
+        this.id = id;
+        this.name = name;
+    }
+    getType() {
+        return "Variable";
+    }
+    toJSON() {
+        return { type: "Variable", id: this.id, name: this.name };
+    }
+    resolve(env) {
+        let current = this;
+        const seen = new Set();
+        while (current.logicTermType === "Variable") {
+            const v = current;
+            if (seen.has(v.id))
+                break;
+            seen.add(v.id);
+            const bound = env.get(v.id);
+            if (!bound)
+                break;
+            current = bound;
+        }
+        return current;
+    }
+    unify(other, env) {
+        const r1 = this.resolve(env);
+        const r2 = other.resolve(env);
+        if (r1 === r2)
+            return boolean(true);
+        if (r1.logicTermType === "Variable") {
+            const v1 = r1;
+            if (r2.occurs(v1, env))
+                return boolean(false);
+            env.set(v1.id, r2);
+            return boolean(true);
+        }
+        if (r2.logicTermType === "Variable") {
+            const v2 = r2;
+            if (r1.occurs(v2, env))
+                return boolean(false);
+            env.set(v2.id, r1);
+            return boolean(true);
+        }
+        // If r1 resolved to a non-variable, delegate to its unify logic
+        return r1.unify(r2, env);
+    }
+    occurs(v, env) {
+        const resolved = this.resolve(env);
+        if (resolved.logicTermType === "Variable")
+            return resolved.id === v.id;
+        return resolved.occurs(v, env);
+    }
+    instantiate(env, seen = new Set()) {
+        let current = this;
+        const localSeen = new Set(seen);
+        while (current.logicTermType === "Variable") {
+            const v = current;
+            if (localSeen.has(v.id))
+                return current;
+            localSeen.add(v.id);
+            const bound = env.get(v.id);
+            if (!bound)
+                return current;
+            current = bound;
+        }
+        return current.instantiate(env, localSeen);
+    }
+    toPrimitive(env) {
+        const resolved = this.resolve(env);
+        if (resolved === this)
+            return new YuString(this.name);
+        return resolved.toPrimitive(env);
+    }
+    toString() {
+        return `${this.name}_${this.id}`;
+    }
+}
+/**
+ * Represents a constant value (Numbers, Strings, Booleans).
+ */
+export class ConstantTerm extends LogicTerm {
+    value;
+    logicTermType = "Constant";
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    equals(other) {
+        if (!(other instanceof ConstantTerm))
+            return boolean(false);
+        return this.value.equals(other.value);
+    }
+    compare(other) {
+        if (!(other instanceof ConstantTerm))
+            return raise(error("ConstantTerm", "Type mismatch in compare"));
+        return this.value.compare(other.value);
+    }
+    getType() {
+        return "Constant";
+    }
+    toJSON() {
+        return this.value.toJSON();
+    }
+    resolve() {
+        return this;
+    }
+    occurs() {
+        return false;
+    }
+    unify(other, env) {
+        const r2 = other.resolve(env);
+        if (r2.logicTermType === "Wildcard")
+            return boolean(true);
+        if (r2.logicTermType === "Variable") {
+            env.set(r2.id, this);
+            return boolean(true);
+        }
+        if (r2.logicTermType === "Constant") {
+            return this.value.equals(r2.value);
+        }
+        return boolean(false);
+    }
+    instantiate() {
+        return this;
+    }
+    toPrimitive() {
+        return this.value;
+    }
+    toString() {
+        return this.value.toString();
+    }
+}
+/**
+ * Represents a compound structure (Functors, Constructors, Application).
+ */
+export class CompoundTerm extends LogicTerm {
+    functor;
+    args;
+    logicTermType = "Compound";
+    constructor(functor, args) {
+        super();
+        this.functor = functor;
+        this.args = args;
+    }
+    getType() {
+        return "Compound";
+    }
+    toJSON() {
+        return {
+            type: "Compound",
+            functor: this.functor,
+            args: this.args.map((a) => a.toJSON()),
+        };
+    }
+    resolve() {
+        return this;
+    }
+    occurs(v, env) {
+        return this.args.some((arg) => arg.occurs(v, env));
+    }
+    unify(other, env) {
+        const r2 = other.resolve(env);
+        if (r2.logicTermType === "Wildcard")
+            return boolean(true);
+        if (r2.logicTermType === "Variable") {
+            const v2 = r2;
+            if (this.occurs(v2, env))
+                return boolean(false);
+            env.set(v2.id, this);
+            return boolean(true);
+        }
+        if (r2.logicTermType === "Compound") {
+            const c2 = r2;
+            if (this.functor !== c2.functor)
+                return boolean(false);
+            if (this.args.length !== c2.args.length)
+                return boolean(false);
+            return unifyArray(this.args, c2.args, env);
+        }
+        return boolean(false);
+    }
+    instantiate(env, seen) {
+        return new CompoundTerm(this.functor, this.args.map((a) => a.instantiate(env, seen)));
+    }
+    toPrimitive(env) {
+        const args = this.args.map((a) => a.toPrimitive(env));
+        // represent as a RuntimeObject
+        return new RuntimeObject(this.functor, this.functor, new Map(args.map((v, i) => [`_${i}`, v])), new Map());
+    }
+    toString() {
+        return `${this.functor}(${this.args.map((a) => a.toString()).join(", ")})`;
+    }
+}
+/**
+ * Represents the wildcard pattern (_).
+ */
+export class WildcardTerm extends LogicTerm {
+    logicTermType = "Wildcard";
+    equals(other) {
+        return boolean(other instanceof WildcardTerm);
+    }
+    compare(other) {
+        return new StepCommand(new YuNumber(0));
+    }
+    getType() {
+        return "Wildcard";
+    }
+    toJSON() {
+        return "_";
+    }
+    resolve() {
+        return this;
+    }
+    occurs() {
+        return false;
+    }
+    unify(other, env) {
+        return boolean(true);
+    }
+    instantiate() {
+        return this;
+    }
+    toPrimitive() {
+        return YuNil.getInstance();
+    }
+    toString() {
+        return "_";
+    }
+}
+/**
+ * Represents a List [x, y, z].
+ */
+export class ListTerm extends LogicTerm {
+    elements;
+    logicTermType = "List";
+    constructor(elements) {
+        super();
+        this.elements = elements;
+    }
+    getType() {
+        return "ListTerm";
+    }
+    toJSON() {
+        return this.elements.map((e) => e.toJSON());
+    }
+    resolve() {
+        return this;
+    }
+    occurs(v, env) {
+        return this.elements.some((el) => el.occurs(v, env));
+    }
+    unify(other, env) {
+        const r2 = other.resolve(env);
+        if (r2.logicTermType === "Wildcard")
+            return boolean(true);
+        if (r2.logicTermType === "Variable") {
+            const v2 = r2;
+            if (this.occurs(v2, env))
+                return boolean(false);
+            env.set(v2.id, this);
+            return boolean(true);
+        }
+        if (r2.logicTermType === "List") {
+            const l2 = r2;
+            if (this.elements.length !== l2.elements.length)
+                return boolean(false);
+            return unifyArray(this.elements, l2.elements, env);
+        }
+        if (r2.logicTermType === "Cons") {
+            // Delegate to ConsTerm.unify to leverage iterative unrolling
+            return r2.unify(this, env);
+        }
+        return boolean(false);
+    }
+    instantiate(env, seen) {
+        return new ListTerm(this.elements.map((e) => e.instantiate(env, seen)));
+    }
+    toPrimitive(env) {
+        return new YuArray(this.elements.map((e) => e.toPrimitive(env)));
+    }
+    toString() {
+        return `[${this.elements.map((e) => e.toString()).join(", ")}]`;
+    }
+}
+/**
+ * Represents a Cons cell (head:tail).
+ */
+export class ConsTerm extends LogicTerm {
+    head;
+    tail;
+    logicTermType = "Cons";
+    constructor(head, tail) {
+        super();
+        this.head = head;
+        this.tail = tail;
+    }
+    getType() {
+        return "ConsTerm";
+    }
+    toJSON() {
+        return { head: this.head.toJSON(), tail: this.tail.toJSON() };
+    }
+    resolve() {
+        return this;
+    }
+    occurs(v, env) {
+        let curr = this;
+        while (curr.logicTermType === "Cons") {
+            const c = curr;
+            if (c.head.occurs(v, env))
+                return true;
+            curr = c.tail.resolve(env);
+        }
+        return curr.occurs(v, env);
+    }
+    unify(other, env) {
+        const step = (curr1, curr2) => {
+            const r1 = curr1.resolve(env);
+            const r2 = curr2.resolve(env);
+            if (r1.logicTermType === "Cons") {
+                const c1 = r1;
+                if (r2.logicTermType === "Wildcard")
+                    return boolean(true);
+                if (r2.logicTermType === "Variable") {
+                    const v2 = r2;
+                    if (c1.occurs(v2, env))
+                        return boolean(false);
+                    env.set(v2.id, c1);
+                    return boolean(true);
+                }
+                if (r2.logicTermType === "Cons") {
+                    const c2 = r2;
+                    return new BindCommand(c1.head.unify(c2.head, env), (res) => {
+                        if (res instanceof YuBoolean && res.value) {
+                            return step(c1.tail, c2.tail);
+                        }
+                        return boolean(false);
+                    });
+                }
+                if (r2.logicTermType === "List") {
+                    const l2 = r2;
+                    if (l2.elements.length === 0)
+                        return boolean(false);
+                    const [h, ...t] = l2.elements;
+                    return new BindCommand(c1.head.unify(h, env), (res) => {
+                        if (res instanceof YuBoolean && res.value) {
+                            return step(c1.tail, new ListTerm(t));
+                        }
+                        return boolean(false);
+                    });
+                }
+                return boolean(false);
+            }
+            return r1.unify(r2, env);
+        };
+        return step(this, other);
+    }
+    instantiate(env, seen) {
+        let curr = this;
+        const heads = [];
+        while (curr.logicTermType === "Cons") {
+            const c = curr;
+            heads.push(c.head.instantiate(env, seen));
+            curr = c.tail.resolve(env);
+        }
+        let result = curr.instantiate(env, seen);
+        for (let i = heads.length - 1; i >= 0; i--) {
+            result = new ConsTerm(heads[i], result);
+        }
+        return result;
+    }
+    toPrimitive(env) {
+        let curr = this;
+        const heads = [];
+        while (curr.logicTermType === "Cons") {
+            const c = curr;
+            heads.push(c.head.toPrimitive(env));
+            curr = c.tail.resolve(env);
+        }
+        const tailVal = curr.toPrimitive(env);
+        let res = tailVal;
+        for (let i = heads.length - 1; i >= 0; i--) {
+            const seq = res.asSequence;
+            if (seq && seq instanceof YuArray) {
+                res = new YuArray([heads[i], ...seq]);
+            }
+            else {
+                // Hybrid cons case?
+                res = new YuArray([heads[i], res]);
+            }
+        }
+        return res;
+    }
+    toString() {
+        return `(${this.head.toString()}:${this.tail.toString()})`;
+    }
+}

package/dist/interpreter/components/logic/LogicTranslator.d.ts

@@ -1,14 +1,30 @@
-import { Expression, Pattern, PrimitiveValue } from "yukigo-ast";
-import { Substitution } from "./LogicResolver.js";
-import { ExpressionEvaluator } from "../../utils.js";
-import { Continuation, Thunk } from "../../trampoline.js";
+import { Expression, Pattern } from "yukigo-ast";
+import { VariableTerm } from "./LogicTerm.js";
 import { RuntimeContext } from "../RuntimeContext.js";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { YuValue } from "../../primitives/YuValue.js";
+import { LogicTerm, Substitution } from "../../primitives/index.js";
+import { Evaluator } from "../evaluators/BaseEvaluator.js";
 export declare class LogicTranslator {
     private evaluator;
     private ctx;
-    constructor(evaluator: ExpressionEvaluator, ctx: RuntimeContext);
-    patternToPrimitive(pat: Pattern): PrimitiveValue | undefined;
-    expressionToPattern<R = Pattern>(expr: Expression, k: Continuation<Pattern, R>): Thunk<R>;
-    primitiveToPattern(val: PrimitiveValue): Pattern;
-    instantiateExpressionAsPattern<R = Pattern>(expr: Expression, substs: Substitution, k: Continuation<Pattern, R>): Thunk<R>;
+    constructor(evaluator: Evaluator, ctx: RuntimeContext);
+    getNextId(name: string): number;
+    getName(id: number): string | undefined;
+    /**
+     * Translates a Pattern (AST) into a LogicTerm (Runtime).
+     */
+    patternToTerm(pat: Pattern, scope?: Map<string, VariableTerm>): LogicTerm;
+    /**
+     * Converts a PrimitiveValue to a LogicTerm.
+     */
+    primitiveToTerm(val: YuValue): LogicTerm;
+    /**
+     * Evaluates an expression and returns its LogicTerm representation via the Kernel.
+     */
+    expressionToTerm(expr: Expression, scope?: Map<string, VariableTerm>): ExecutionCommand;
+    /**
+     * Instantiates an expression as a logic term, resolving logic variables.
+     */
+    instantiateExpressionAsTerm(expr: Expression, substs: Substitution, scope?: Map<string, VariableTerm>): ExecutionCommand;
 }