yukigo 0.1.0 → 0.2.0

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

@@ -0,0 +1,471 @@
+import { Fact, FunctorPattern, ListPattern, LiteralPattern, Rule, VariablePattern, WildcardPattern, isRuntimePredicate, UnguardedBody, Findall, ConsPattern, Equation, SymbolPrimitive, Goal, Exist, LogicConstraint, Sequence, Not, ComparisonOperation, UnifyOperation, ApplicationPattern, TuplePattern, ConstructorPattern, UnionPattern, AsPattern, TypePattern, AssignOperation, ArithmeticBinaryOperation, ArithmeticUnaryOperation, ConsExpression, ListPrimitive, TupleExpression, If, Forall, Call, ListBinaryOperation, ListUnaryOperation, LogicalBinaryOperation, LogicalUnaryOperation, BitwiseBinaryOperation, BitwiseUnaryOperation, StringOperation, isUnguardedBody, } from "yukigo-ast";
+/**
+ * Creates a successful logic result.
+ */
+export function success(substs) {
+    return { success: true, substs };
+}
+/**
+ * Unifies two patterns given an existing set of substitutions.
+ * Returns the updated substitution map or null if unification fails.
+ */
+export function unify(t1, t2, argEnv) {
+    const env = argEnv ? new Map(argEnv) : new Map();
+    return unifyInPlace(t1, t2, env) ? env : null;
+}
+/**
+ * Internal unification that modifies the environment in place for efficiency during recursion.
+ */
+function unifyInPlace(t1, t2, env) {
+    const r1 = resolve(t1, env);
+    const r2 = resolve(t2, env);
+    if (r1 === r2)
+        return true;
+    if (r1 instanceof WildcardPattern || r2 instanceof WildcardPattern) {
+        return true;
+    }
+    if (r1 instanceof VariablePattern) {
+        env.set(r1.name.value, r2);
+        return true;
+    }
+    if (r2 instanceof VariablePattern) {
+        env.set(r2.name.value, r1);
+        return true;
+    }
+    if (r1 instanceof LiteralPattern && r2 instanceof LiteralPattern) {
+        return r1.name.equals(r2.name);
+    }
+    if (r1 instanceof FunctorPattern && r2 instanceof FunctorPattern) {
+        if (r1.identifier.value !== r2.identifier.value)
+            return false;
+        if (r1.args.length !== r2.args.length)
+            return false;
+        for (let i = 0; i < r1.args.length; i++) {
+            if (!unifyInPlace(r1.args[i], r2.args[i], env))
+                return false;
+        }
+        return true;
+    }
+    if (r1 instanceof ListPattern && r2 instanceof ListPattern) {
+        if (r1.elements.length !== r2.elements.length)
+            return false;
+        for (let i = 0; i < r1.elements.length; i++) {
+            if (!unifyInPlace(r1.elements[i], r2.elements[i], env))
+                return false;
+        }
+        return true;
+    }
+    if (r1 instanceof ConsPattern && r2 instanceof ConsPattern) {
+        let curr1 = r1;
+        let curr2 = r2;
+        while (curr1 instanceof ConsPattern && curr2 instanceof ConsPattern) {
+            if (!unifyInPlace(curr1.left, curr2.left, env))
+                return false;
+            curr1 = resolve(curr1.right, env);
+            curr2 = resolve(curr2.right, env);
+        }
+        return unifyInPlace(curr1, curr2, env);
+    }
+    if (r1 instanceof ConsPattern && r2 instanceof ListPattern) {
+        if (r2.elements.length === 0)
+            return false;
+        const [head, ...tail] = r2.elements;
+        return (unifyInPlace(r1.left, head, env) &&
+            unifyInPlace(r1.right, new ListPattern(tail), env));
+    }
+    if (r1 instanceof ListPattern && r2 instanceof ConsPattern) {
+        if (r1.elements.length === 0)
+            return false;
+        const [head, ...tail] = r1.elements;
+        return (unifyInPlace(head, r2.left, env) &&
+            unifyInPlace(new ListPattern(tail), r2.right, env));
+    }
+    return false;
+}
+/**
+ * Follows variable bindings in the substitution map until a non-variable or unbound variable is found.
+ */
+export function resolve(node, env) {
+    let current = node;
+    const seen = new Set();
+    while (current instanceof VariablePattern) {
+        const name = current.name.value;
+        if (seen.has(name))
+            break;
+        seen.add(name);
+        const bound = env.get(name);
+        if (!bound)
+            break;
+        current = bound;
+    }
+    return current;
+}
+class Instantiator {
+    substs;
+    seen;
+    constructor(substs, seen = new Set()) {
+        this.substs = substs;
+        this.seen = seen;
+    }
+    visitVariablePattern(node) {
+        const name = node.name.value;
+        if (this.seen.has(name))
+            return node;
+        const val = this.substs.get(name);
+        if (val) {
+            const nextSeen = new Set(this.seen);
+            nextSeen.add(name);
+            return new Instantiator(this.substs, nextSeen).instantiate(val);
+        }
+        return node;
+    }
+    visitLiteralPattern(node) {
+        return node;
+    }
+    visitApplicationPattern(node) {
+        return new ApplicationPattern(node.identifier, node.args.map((arg) => this.instantiate(arg)), node.loc);
+    }
+    visitTuplePattern(node) {
+        return new TuplePattern(node.elements.map((el) => this.instantiate(el)), node.loc);
+    }
+    visitListPattern(node) {
+        return new ListPattern(node.elements.map((el) => this.instantiate(el)), node.loc);
+    }
+    visitFunctorPattern(node) {
+        return new FunctorPattern(node.identifier, node.args.map((arg) => this.instantiate(arg)), node.loc);
+    }
+    visitAsPattern(node) {
+        return new AsPattern(this.instantiate(node.left), this.instantiate(node.right), node.loc);
+    }
+    visitWildcardPattern(node) {
+        return node;
+    }
+    visitUnionPattern(node) {
+        return new UnionPattern(node.elements.map((el) => this.instantiate(el)), node.loc);
+    }
+    visitConstructorPattern(node) {
+        return new ConstructorPattern(node.identifier, node.args.map((arg) => this.instantiate(arg)), node.loc);
+    }
+    visitConsPattern(node) {
+        return new ConsPattern(this.instantiate(node.left), this.instantiate(node.right), node.loc);
+    }
+    visitTypePattern(node) {
+        return new TypePattern(node.targetType, node.innerPattern ? this.instantiate(node.innerPattern) : undefined, node.loc);
+    }
+    instantiate(pattern) {
+        return pattern.accept(this);
+    }
+}
+/**
+ * Fully instantiates a pattern by replacing all bound variables with their values.
+ */
+export function instantiate(pattern, substs, seen = new Set()) {
+    return new Instantiator(substs, seen).instantiate(pattern);
+}
+let variableCounter = 0;
+class LogicVariableRenamer {
+    renames;
+    freshId;
+    constructor(renames, freshId) {
+        this.renames = renames;
+        this.freshId = freshId;
+    }
+    rename(node) {
+        if (!node || typeof node !== "object")
+            return node;
+        if (typeof node.accept === "function") {
+            return node.accept(this);
+        }
+        return node;
+    }
+    visitFact(node) {
+        return new Fact(node.identifier, node.patterns.map((p) => this.rename(p)), node.loc);
+    }
+    visitRule(node) {
+        const renamedEquations = node.equations.map((eq) => {
+            const body = eq.body;
+            if (!isUnguardedBody(body))
+                throw new Error("GuardedBody renaming not implemented");
+            return new Equation(eq.patterns.map((p) => this.rename(p)), body.accept(this), eq.returnExpr, eq.loc);
+        });
+        return new Rule(node.identifier, renamedEquations, node.loc);
+    }
+    visitUnguardedBody(node) {
+        return new UnguardedBody(new Sequence(node.sequence.statements.map((stmt) => this.rename(stmt)), node.sequence.loc), node.loc);
+    }
+    // PatternVisitor
+    visitVariablePattern(node) {
+        const name = node.name.value;
+        let newName = this.renames.get(name);
+        if (!newName) {
+            newName = `${name}_${this.freshId}`;
+            this.renames.set(name, newName);
+        }
+        return new VariablePattern(new SymbolPrimitive(newName), node.loc);
+    }
+    visitLiteralPattern(node) {
+        return node;
+    }
+    visitApplicationPattern(node) {
+        return new ApplicationPattern(node.identifier, node.args.map((arg) => this.rename(arg)), node.loc);
+    }
+    visitTuplePattern(node) {
+        return new TuplePattern(node.elements.map((el) => this.rename(el)), node.loc);
+    }
+    visitListPattern(node) {
+        return new ListPattern(node.elements.map((el) => this.rename(el)), node.loc);
+    }
+    visitFunctorPattern(node) {
+        return new FunctorPattern(node.identifier, node.args.map((arg) => this.rename(arg)), node.loc);
+    }
+    visitAsPattern(node) {
+        return new AsPattern(this.rename(node.left), this.rename(node.right), node.loc);
+    }
+    visitWildcardPattern(node) {
+        return node;
+    }
+    visitUnionPattern(node) {
+        return new UnionPattern(node.elements.map((el) => this.rename(el)), node.loc);
+    }
+    visitConstructorPattern(node) {
+        return new ConstructorPattern(node.identifier, node.args.map((arg) => this.rename(arg)), node.loc);
+    }
+    visitConsPattern(node) {
+        return new ConsPattern(this.rename(node.left), this.rename(node.right), node.loc);
+    }
+    visitTypePattern(node) {
+        return new TypePattern(node.targetType, node.innerPattern ? this.rename(node.innerPattern) : undefined, node.loc);
+    }
+    // Expression/Statement Visitor
+    visitSymbolPrimitive(node) {
+        const name = node.value;
+        if (/^[A-Z_]/.test(name) && name !== "_") {
+            let newName = this.renames.get(name);
+            if (!newName) {
+                newName = `${name}_${this.freshId}`;
+                this.renames.set(name, newName);
+            }
+            return new SymbolPrimitive(newName, node.loc);
+        }
+        return node;
+    }
+    visitNumberPrimitive(node) {
+        return node;
+    }
+    visitStringPrimitive(node) {
+        return node;
+    }
+    visitBooleanPrimitive(node) {
+        return node;
+    }
+    visitNilPrimitive(node) {
+        return node;
+    }
+    visitCharPrimitive(node) {
+        return node;
+    }
+    visitGoal(node) {
+        return new Goal(node.identifier, node.args.map((arg) => this.rename(arg)), node.loc);
+    }
+    visitExist(node) {
+        return new Exist(node.identifier, node.patterns.map((pat) => this.rename(pat)), node.loc);
+    }
+    visitFindall(node) {
+        return new Findall(this.rename(node.template), this.rename(node.goal), this.rename(node.bag), node.loc);
+    }
+    visitForall(node) {
+        return new Forall(this.rename(node.condition), this.rename(node.action), node.loc);
+    }
+    visitCall(node) {
+        return new Call(this.rename(node.callee), node.args.map((arg) => this.rename(arg)), node.loc);
+    }
+    visitNot(node) {
+        return new Not(this.rename(node.expression), node.loc);
+    }
+    visitLogicConstraint(node) {
+        return new LogicConstraint(this.rename(node.expression), node.loc);
+    }
+    visitSequence(node) {
+        return new Sequence(node.statements.map((stmt) => this.rename(stmt)), node.loc);
+    }
+    visitIf(node) {
+        return new If(this.rename(node.condition), this.rename(node.then), this.rename(node.elseExpr), node.loc);
+    }
+    visitComparisonOperation(node) {
+        return new ComparisonOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
+    }
+    visitUnifyOperation(node) {
+        return new UnifyOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
+    }
+    visitAssignOperation(node) {
+        return new AssignOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
+    }
+    visitArithmeticBinaryOperation(node) {
+        return new ArithmeticBinaryOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
+    }
+    visitArithmeticUnaryOperation(node) {
+        return new ArithmeticUnaryOperation(node.operator, this.rename(node.operand), node.loc);
+    }
+    visitListBinaryOperation(node) {
+        return new ListBinaryOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
+    }
+    visitListUnaryOperation(node) {
+        return new ListUnaryOperation(node.operator, this.rename(node.operand), node.loc);
+    }
+    visitLogicalBinaryOperation(node) {
+        return new LogicalBinaryOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
+    }
+    visitLogicalUnaryOperation(node) {
+        return new LogicalUnaryOperation(node.operator, this.rename(node.operand), node.loc);
+    }
+    visitBitwiseBinaryOperation(node) {
+        return new BitwiseBinaryOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
+    }
+    visitBitwiseUnaryOperation(node) {
+        return new BitwiseUnaryOperation(node.operator, this.rename(node.operand), node.loc);
+    }
+    visitStringOperation(node) {
+        return new StringOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
+    }
+    visitConsExpression(node) {
+        return new ConsExpression(this.rename(node.head), this.rename(node.tail), node.loc);
+    }
+    visitListPrimitive(node) {
+        return new ListPrimitive(node.value.map((el) => this.rename(el)), node.loc);
+    }
+    visitTupleExpr(node) {
+        return new TupleExpression(node.elements.map((el) => this.rename(el)), node.loc);
+    }
+}
+/**
+ * Renames all variables in a Rule or Fact to fresh names to avoid name clashes during unification.
+ */
+export function renameVariables(clause) {
+    const renames = new Map();
+    const freshId = ++variableCounter;
+    const renamer = new LogicVariableRenamer(renames, freshId);
+    const renamedClause = clause.accept(renamer);
+    return renamedClause;
+}
+class CPSBodyVisitor {
+    solveBody;
+    substs;
+    onSuccess;
+    onNextEq;
+    constructor(solveBody, substs, onSuccess, onNextEq) {
+        this.solveBody = solveBody;
+        this.substs = substs;
+        this.onSuccess = onSuccess;
+        this.onNextEq = onNextEq;
+    }
+    visitUnguardedBody(body) {
+        return this.solveBody(body.sequence.statements, this.substs, this.onSuccess, this.onNextEq);
+    }
+    visitGuardedBody(body) {
+        return this.solveBody([body.condition], this.substs, (guardSubsts, _nextGuardChoice) => {
+            return this.solveBody([body.body], guardSubsts, this.onSuccess, this.onNextEq);
+        }, this.onNextEq);
+    }
+}
+class GoalSolverVisitor {
+    args;
+    baseSubst;
+    solveBody;
+    onSuccess;
+    onNextClause;
+    constructor(args, baseSubst, solveBody, onSuccess, onNextClause) {
+        this.args = args;
+        this.baseSubst = baseSubst;
+        this.solveBody = solveBody;
+        this.onSuccess = onSuccess;
+        this.onNextClause = onNextClause;
+    }
+    visitFact(fact) {
+        if (fact.patterns.length !== this.args.length)
+            return this.onNextClause;
+        const renamedFact = renameVariables(fact);
+        const substs = unifyParameters(renamedFact.patterns, this.args, this.baseSubst);
+        if (substs)
+            return this.onSuccess(substs, this.onNextClause);
+        return this.onNextClause;
+    }
+    visitRule(rule) {
+        if (rule.equations.length === 0)
+            return this.onNextClause;
+        const arity = rule.equations[0].patterns.length;
+        if (arity !== this.args.length)
+            return this.onNextClause;
+        const renamedRule = renameVariables(rule);
+        const tryRuleEq = (eqIndex) => {
+            if (eqIndex >= renamedRule.equations.length)
+                return this.onNextClause;
+            const eq = renamedRule.equations[eqIndex];
+            const substs = unifyParameters(eq.patterns, this.args, this.baseSubst);
+            const onNextEq = () => tryRuleEq(eqIndex + 1);
+            if (!substs)
+                return onNextEq;
+            const bodyVisitor = new CPSBodyVisitor(this.solveBody, substs, this.onSuccess, onNextEq);
+            if (isUnguardedBody(eq.body))
+                return eq.body.accept(bodyVisitor);
+            return eq.body.forEach((branch) => branch.accept(bodyVisitor));
+        };
+        return () => tryRuleEq(0);
+    }
+}
+/**
+ * Solves a single logic goal (predicate call) using CPS.
+ */
+export function solveGoalCPS(ctx, predicateName, args, solveBody, baseSubst, onSuccess, onFailure) {
+    const tryClause = (index) => {
+        let equations;
+        try {
+            const pred = ctx.lookup(predicateName);
+            if (!pred || !isRuntimePredicate(pred))
+                return () => onFailure();
+            equations = pred.equations;
+        }
+        catch (error) {
+            return () => onFailure();
+        }
+        if (index >= equations.length)
+            return () => onFailure();
+        const clause = equations[index];
+        const onNextClause = () => tryClause(index + 1);
+        const clauseVisitor = new GoalSolverVisitor(args, baseSubst, solveBody, onSuccess, onNextClause);
+        return clause.accept(clauseVisitor);
+    };
+    return () => tryClause(0);
+}
+/**
+ * Unifies two lists of parameters. Returns the resulting Substitution or null.
+ */
+function unifyParameters(patterns, args, baseSubst) {
+    let subst = new Map(baseSubst);
+    for (let i = 0; i < patterns.length; i++) {
+        const nextSubst = unify(patterns[i], args[i], subst);
+        if (!nextSubst)
+            return null;
+        subst = nextSubst;
+    }
+    return subst;
+}
+/**
+ * Solves a findall/3 goal using CPS.
+ */
+export function solveFindallCPS(node, currentSubsts, solveBody, onSuccess, onFailure) {
+    const gathered = [];
+    const collectResults = () => {
+        return solveBody([node.goal], currentSubsts, (resultSubsts, next) => {
+            gathered.push(instantiate(node.template, resultSubsts));
+            return () => next();
+        }, () => {
+            const resultList = new ListPattern(gathered);
+            const finalSubsts = unify(node.bag, resultList, currentSubsts);
+            if (finalSubsts) {
+                return onSuccess(finalSubsts, onFailure);
+            }
+            return () => onFailure();
+        });
+    };
+    return collectResults();
+}

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

@@ -0,0 +1,14 @@
+import { Expression, Pattern, PrimitiveValue } from "yukigo-ast";
+import { Substitution } from "./LogicResolver.js";
+import { ExpressionEvaluator } from "../../utils.js";
+import { Continuation, Thunk } from "../../trampoline.js";
+import { RuntimeContext } from "../RuntimeContext.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>;
+}

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

@@ -0,0 +1,99 @@
+import { LiteralPattern, SymbolPrimitive, Variable, VariablePattern, isPattern, NumberPrimitive, StringPrimitive, BooleanPrimitive, ListPrimitive, ListPattern, ConsExpression, ConsPattern, FunctorPattern, } from "yukigo-ast";
+import { instantiate } from "./LogicResolver.js";
+import { InterpreterError } from "../../errors.js";
+export class LogicTranslator {
+    evaluator;
+    ctx;
+    constructor(evaluator, ctx) {
+        this.evaluator = evaluator;
+        this.ctx = ctx;
+    }
+    patternToPrimitive(pat) {
+        if (pat instanceof LiteralPattern) {
+            const primitive = pat.name;
+            return primitive.value;
+        }
+        if (pat instanceof ListPattern) {
+            return pat.elements.map((el) => this.patternToPrimitive(el));
+        }
+        if (pat instanceof ConsPattern) {
+            const head = this.patternToPrimitive(pat.left);
+            const tail = this.patternToPrimitive(pat.right);
+            if (Array.isArray(tail)) {
+                return [head, ...tail];
+            }
+            return [head, tail];
+        }
+        // Return the pattern itself for non-primitive logic terms (VariablePattern, FunctorPattern, etc.)
+        return pat;
+    }
+    expressionToPattern(expr, k) {
+        if (isPattern(expr))
+            return k(expr);
+        if (expr instanceof ListPrimitive) {
+            const results = [];
+            const next = (index) => {
+                if (index >= expr.value.length)
+                    return k(new ListPattern(results));
+                return this.expressionToPattern(expr.value[index], (p) => {
+                    results.push(p);
+                    return () => next(index + 1);
+                });
+            };
+            return next(0);
+        }
+        if (expr instanceof ConsExpression) {
+            return this.expressionToPattern(expr.head, (headPat) => {
+                return () => this.expressionToPattern(expr.tail, (tailPat) => {
+                    return k(new ConsPattern(headPat, tailPat));
+                });
+            });
+        }
+        if (expr instanceof Variable || expr instanceof SymbolPrimitive) {
+            const name = expr instanceof Variable ? expr.identifier.value : expr.value;
+            if (this.ctx.isDefined(name)) {
+                return this.evaluator.evaluate(expr, (val) => {
+                    return k(this.primitiveToPattern(val));
+                });
+            }
+            return k(new VariablePattern(expr instanceof Variable ? expr.identifier : expr));
+        }
+        return this.evaluator.evaluate(expr, (val) => {
+            return k(this.primitiveToPattern(val));
+        });
+    }
+    primitiveToPattern(val) {
+        if (isPattern(val)) {
+            return val;
+        }
+        if (typeof val === "number") {
+            return new LiteralPattern(new NumberPrimitive(val));
+        }
+        if (typeof val === "string") {
+            return new LiteralPattern(new StringPrimitive(val));
+        }
+        if (typeof val === "boolean") {
+            return new LiteralPattern(new BooleanPrimitive(val));
+        }
+        if (Array.isArray(val)) {
+            return new ListPattern(val.map((v) => this.primitiveToPattern(v)));
+        }
+        if (val &&
+            typeof val === "object" &&
+            "type" in val &&
+            val.type === "Object") {
+            // Convert RuntimeObject to FunctorPattern for logic matching
+            const args = [];
+            for (const [_, fieldVal] of val.fields) {
+                args.push(this.primitiveToPattern(fieldVal));
+            }
+            return new FunctorPattern(new SymbolPrimitive(val.className || val.identifier), args);
+        }
+        throw new InterpreterError("primitiveToPattern", `Cannot convert value ${val} to Logic Pattern`);
+    }
+    instantiateExpressionAsPattern(expr, substs, k) {
+        return this.expressionToPattern(expr, (patternBase) => {
+            return k(instantiate(patternBase, substs));
+        });
+    }
+}

package/dist/interpreter/components/runtimes/FunctionRuntime.d.ts

@@ -0,0 +1,12 @@
+import { PrimitiveValue, RuntimeFunction } from "yukigo-ast";
+import { Continuation, CPSThunk, Thunk } from "../../trampoline.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+export declare class FunctionRuntime {
+    private context;
+    constructor(context: RuntimeContext);
+    apply(func: RuntimeFunction, args: PrimitiveValue[], k: Continuation<PrimitiveValue>): Thunk<PrimitiveValue>;
+    applyArguments(func: RuntimeFunction, args: (PrimitiveValue | (() => PrimitiveValue))[]): CPSThunk<PrimitiveValue>;
+    private preloadDefinitions;
+    private patternsMatch;
+    private evaluateSequence;
+}