yukigo 0.2.3 → 0.3.2

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

@@ -1,259 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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>;