yukigo 0.2.0 → 0.2.2

package/dist/src/interpreter/components/logic/LogicEngine.js

@@ -0,0 +1,259 @@
+import { Exist, Findall, Goal, LogicConstraint, Sequence, SymbolPrimitive, VariablePattern, } from "yukigo-ast";
+import { solveFindallCPS, solveGoalCPS, unify, instantiate, } from "./LogicResolver.js";
+import { createStream } from "../../utils.js";
+import { InterpreterVisitor } from "../Visitor.js";
+import { LogicTranslator } from "./LogicTranslator.js";
+import { trampoline } from "../../trampoline.js";
+import { PatternResolver } from "../PatternMatcher.js";
+export class LogicEngine {
+    context;
+    translator;
+    constructor(evaluator, context) {
+        this.context = context;
+        this.translator = new LogicTranslator(evaluator, this.context);
+    }
+    unifyExpr(left, right, k) {
+        return this.translator.instantiateExpressionAsPattern(left, new Map(), (p1) => {
+            return () => this.translator.instantiateExpressionAsPattern(right, new Map(), (p2) => {
+                return k(unify(p1, p2, new Map()) !== null);
+            });
+        });
+    }
+    solveQuery(node, k, modeOverride) {
+        const mode = modeOverride || this.context.config.outputMode || "first";
+        if (mode === "all") {
+            return this.collectAllResults(node.expressions, new Map(), (results) => k(results.map((s) => this.formatLogicResult(s))));
+        }
+        else if (mode === "stream") {
+            return k(this.createLazyStream(node.expressions, new Map()));
+        }
+        // "first" mode
+        return this.solveConjunction(node.expressions, new Map(), (s) => k(this.formatLogicResult(s)), () => k(false));
+    }
+    solveGoal(node, k, modeOverride) {
+        return this.prepareLogicTargetCPS(node, new Map(), ({ id, patterns }) => {
+            // Goals evaluated as expressions should usually default to "first"
+            // to avoid combinatorial explosion when they are part of a sequence.
+            const mode = modeOverride || this.context.config.outputMode || "first";
+            if (mode === "all") {
+                return this.collectAllResultsForGoal(id, patterns, new Map(), (results) => k(results.map((s) => this.formatLogicResult(s))));
+            }
+            else if (mode === "stream") {
+                return k(this.createLazyStreamForGoal(id, patterns, new Map()));
+            }
+            return solveGoalCPS(this.context, id, patterns, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), new Map(), (s) => k(this.formatLogicResult(s)), () => k(false));
+        });
+    }
+    solveNot(node, k) {
+        return () => this.solveConjunction([node.expression], new Map(), () => k(false), () => k(true));
+    }
+    solveFindall(node, k) {
+        return solveFindallCPS(node, new Map(), (body, substs, onSuccess, onFailure) => this.solveConjunction(body, substs, onSuccess, onFailure), (finalSubsts) => {
+            const pat = finalSubsts.get(node.bag.name.value);
+            const val = this.translator.patternToPrimitive(pat);
+            return k(val);
+        }, () => k([]));
+    }
+    solveForall(node, k) {
+        return this.solveConjunction([node.condition], new Map(), (condSubsts, nextCond) => {
+            return this.solveConjunction([node.action], condSubsts, () => nextCond, () => k(false));
+        }, () => k(true));
+    }
+    solveExist(node, k, modeOverride) {
+        return this.prepareLogicTargetCPS(node, new Map(), ({ id, patterns }) => {
+            // Exists evaluated as expressions should usually default to "first"
+            const mode = modeOverride || this.context.config.outputMode || "first";
+            if (mode === "all") {
+                return this.collectAllResultsForGoal(id, patterns, new Map(), (results) => k(results.map((s) => this.formatLogicResult(s))));
+            }
+            else if (mode === "stream") {
+                return k(this.createLazyStreamForGoal(id, patterns, new Map()));
+            }
+            return solveGoalCPS(this.context, id, patterns, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), new Map(), (s) => k(this.formatLogicResult(s)), () => k(false));
+        });
+    }
+    solveConjunction(nodes, substs, onSuccess, onFailure) {
+        if (this.context.config.debug)
+            console.log(`[LogicEngine] Solving conjunction.`);
+        if (nodes.length === 0) {
+            if (this.context.config.debug)
+                console.log(`[LogicEngine] Nothing else to solve. Success.`);
+            return onSuccess(substs, onFailure);
+        }
+        const [head, ...tail] = nodes;
+        return () => this.solveSingle(head, substs, (newSubsts, next) => {
+            return this.solveConjunction(tail, newSubsts, onSuccess, next);
+        }, onFailure);
+    }
+    solveSingle(node, substs, onSuccess, onFailure) {
+        if (this.isLogicGoal(node))
+            return () => this.solveLogicGoal(node, substs, onSuccess, onFailure);
+        return () => this.solveCondition(node, substs, onSuccess, onFailure);
+    }
+    solveLogicGoal(goal, substs, onSuccess, onFailure) {
+        if (goal instanceof LogicConstraint) {
+            return () => this.solveConjunction([goal.expression], substs, onSuccess, onFailure);
+        }
+        if (goal instanceof Sequence) {
+            return () => this.solveConjunction(goal.statements, substs, onSuccess, onFailure);
+        }
+        if (goal instanceof Findall) {
+            return solveFindallCPS(goal, substs, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), onSuccess, onFailure);
+        }
+        if (this.context.config.debug) {
+            console.log(`[LogicEngine] Solving logic goal: ${goal.identifier.value}.`);
+        }
+        return this.prepareLogicTargetCPS(goal, substs, ({ id, patterns }) => {
+            return solveGoalCPS(this.context, id, patterns, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), substs, onSuccess, onFailure);
+        });
+    }
+    solveCondition(expr, substs, onSuccess, onFailure) {
+        this.createLocalEnv(substs);
+        const localEvaluator = new InterpreterVisitor(this.context);
+        return localEvaluator.evaluate(expr, (result) => {
+            if (result !== undefined && result !== false) {
+                let currentSubsts = new Map(substs);
+                for (const [name, val] of this.context.env.head) {
+                    const pat = this.translator.primitiveToPattern(val);
+                    const unified = unify(new VariablePattern(new SymbolPrimitive(name)), pat, currentSubsts);
+                    if (unified) {
+                        currentSubsts = unified;
+                    }
+                    else {
+                        return onFailure();
+                    }
+                }
+                return onSuccess(currentSubsts, onFailure);
+            }
+            return onFailure();
+        });
+    }
+    isLogicGoal(node) {
+        return (node instanceof Goal ||
+            node instanceof Exist ||
+            node instanceof Findall ||
+            node instanceof LogicConstraint ||
+            node instanceof Sequence);
+    }
+    createLocalEnv(substs) {
+        this.context.pushEnv(new Map());
+        for (const [name, pattern] of substs) {
+            const resolvedPattern = instantiate(pattern, substs);
+            const value = this.translator.patternToPrimitive(resolvedPattern);
+            this.context.define(name, value);
+            // map base name if it was standardized apart ("X_1" -> "X")
+            const baseNameMatch = name.match(/^(.*)_\d+$/);
+            if (baseNameMatch) {
+                const baseName = baseNameMatch[1];
+                if (!this.context.env.head.has(baseName)) {
+                    this.context.define(baseName, value);
+                }
+            }
+        }
+    }
+    prepareLogicTargetCPS(node, substs, k) {
+        const id = node.identifier.value;
+        if (node instanceof Goal) {
+            const patterns = [];
+            const next = (index) => {
+                if (index >= node.args.length)
+                    return k({ id, patterns });
+                return this.translator.instantiateExpressionAsPattern(node.args[index], substs, (p) => {
+                    patterns.push(p);
+                    return () => next(index + 1);
+                });
+            };
+            return () => next(0);
+        }
+        else {
+            const patterns = node.patterns.map((pat) => instantiate(pat, substs));
+            return k({ id, patterns });
+        }
+    }
+    collectAllResults(nodes, substs, k) {
+        const results = [];
+        return this.solveConjunction(nodes, substs, (s, next) => {
+            if (this.context.config.debug)
+                console.log(`[LogicEngine] Pushing { ${Array.from(s).map(([k, pat]) => `${k} -> ${pat.accept(new PatternResolver())}`)} } to results`);
+            results.push(s);
+            if (this.context.config.debug)
+                console.log(`[LogicEngine] Collected results: ${results.map((s) => `{ ${Array.from(s).map(([k, pat]) => `${k} -> ${pat.accept(new PatternResolver())}`)} }`)}`);
+            return next;
+        }, () => k(results));
+    }
+    collectAllResultsForGoal(id, patterns, substs, k) {
+        const results = [];
+        return solveGoalCPS(this.context, id, patterns, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), substs, (s, next) => {
+            results.push(s);
+            return next;
+        }, () => k(results));
+    }
+    createLazyStream(nodes, substs) {
+        let currentSubst = null;
+        let currentNext = null;
+        let thunk = this.solveConjunction(nodes, substs, (s, next) => {
+            currentSubst = s;
+            currentNext = next;
+            return null;
+        }, () => {
+            currentSubst = null;
+            return null;
+        });
+        return createStream(() => {
+            return {
+                next: () => {
+                    trampoline(thunk);
+                    if (currentSubst) {
+                        const res = this.formatLogicResult(currentSubst);
+                        thunk = currentNext();
+                        return { value: res, done: false };
+                    }
+                    return { value: undefined, done: true };
+                },
+            };
+        });
+    }
+    createLazyStreamForGoal(id, patterns, substs) {
+        let currentSubst = null;
+        let currentNext = null;
+        let thunk = solveGoalCPS(this.context, id, patterns, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), substs, (s, next) => {
+            currentSubst = s;
+            currentNext = next;
+            return null;
+        }, () => {
+            currentSubst = null;
+            return null;
+        });
+        return createStream(() => {
+            return {
+                next: () => {
+                    trampoline(thunk);
+                    if (currentSubst) {
+                        const res = this.formatLogicResult(currentSubst);
+                        thunk = currentNext();
+                        return { value: res, done: false };
+                    }
+                    return { value: undefined, done: true };
+                },
+            };
+        });
+    }
+    formatLogicResult(substs) {
+        const solutions = new Map();
+        substs.forEach((pattern, key) => {
+            const val = this.translator.patternToPrimitive(pattern);
+            if (val !== undefined) {
+                solutions.set(key, val);
+                // Also map base name if it was standardized apart (e.g., "X_1" -> "X")
+                const baseNameMatch = key.match(/^(.*)_\d+$/);
+                if (baseNameMatch) {
+                    const baseName = baseNameMatch[1];
+                    if (!solutions.has(baseName)) {
+                        solutions.set(baseName, val);
+                    }
+                }
+            }
+        });
+        return { success: true, solutions };
+    }
+}

package/dist/src/interpreter/components/logic/LogicResolver.d.ts

@@ -0,0 +1,53 @@
+import { Fact, Pattern, Rule, Findall } from "yukigo-ast";
+import { Thunk } from "../../trampoline.js";
+import { LogicExecutable } from "./LogicEngine.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+/**
+ * A Substitution maps variable names to their bound patterns.
+ */
+export type Substitution = Map<string, Pattern>;
+/**
+ * Internal result of a logic operation.
+ */
+export type InternalLogicResult = {
+    success: true;
+    substs: Substitution;
+};
+/**
+ * Backtracking continuations.
+ */
+export type SuccessCont = (substs: Substitution, next: () => Thunk<any>) => Thunk<any>;
+export type FailureCont = () => Thunk<any>;
+/**
+ * A function that can solve a sequence of logic goals/expressions in CPS.
+ */
+export type BodySolverCPS = (expressions: LogicExecutable[], env: Substitution, onSuccess: SuccessCont, onFailure: FailureCont) => Thunk<any>;
+/**
+ * Creates a successful logic result.
+ */
+export declare function success(substs: Substitution): InternalLogicResult;
+/**
+ * Unifies two patterns given an existing set of substitutions.
+ * Returns the updated substitution map or null if unification fails.
+ */
+export declare function unify(t1: Pattern, t2: Pattern, argEnv?: Substitution): Substitution | null;
+/**
+ * Follows variable bindings in the substitution map until a non-variable or unbound variable is found.
+ */
+export declare function resolve(node: Pattern, env: Substitution): Pattern;
+/**
+ * Fully instantiates a pattern by replacing all bound variables with their values.
+ */
+export declare function instantiate(pattern: Pattern, substs: Substitution, seen?: Set<string>): Pattern;
+/**
+ * Renames all variables in a Rule or Fact to fresh names to avoid name clashes during unification.
+ */
+export declare function renameVariables<T extends Rule | Fact>(clause: T): T;
+/**
+ * Solves a single logic goal (predicate call) using CPS.
+ */
+export declare function solveGoalCPS(ctx: RuntimeContext, predicateName: string, args: Pattern[], solveBody: BodySolverCPS, baseSubst: Substitution, onSuccess: SuccessCont, onFailure: FailureCont): Thunk<any>;
+/**
+ * Solves a findall/3 goal using CPS.
+ */
+export declare function solveFindallCPS(node: Findall, currentSubsts: Substitution, solveBody: BodySolverCPS, onSuccess: SuccessCont, onFailure: FailureCont): Thunk<any>;