yukigo 0.2.3 → 0.3.2

package/dist/interpreter/components/kernel/commands.js

@@ -0,0 +1,203 @@
+import { YukigoKernel } from "./index.js";
+import { ListTerm } from "../logic/LogicTerm.js";
+import { isLogicResult, LogicResult, LogicAnswer, } from "../../primitives/index.js";
+import { InterpreterVisitor } from "../evaluators/index.js";
+/**
+ * Commands the Kernel to evaluate an AST node.
+ */
+export class EvalCommand {
+    node;
+    name = "EVAL";
+    constructor(node) {
+        this.node = node;
+    }
+    execute(kernel) {
+        return kernel.evaluator.evaluate(this.node);
+    }
+    createTraceEntry() {
+        const { constructor, loc } = this.node;
+        const frame = {
+            nodeType: constructor.name,
+            loc,
+        };
+        const startLoc = loc ? `${loc.line}:${loc.column}:` : "";
+        const key = `${startLoc}${constructor.name}`;
+        return { key, frame };
+    }
+}
+/**
+ * Commands the Kernel to move to the next step with a produced value.
+ * It triggers the popping of the continuation stack in the kernel.
+ */
+export class StepCommand {
+    value;
+    name = "STEP";
+    constructor(value) {
+        this.value = value;
+    }
+    execute(kernel) {
+        return kernel.popAndExecute(this.value);
+    }
+    createTraceEntry() { }
+}
+/**
+ * Commands the Kernel to bind a produced value to a continuation.
+ * It pushes the continuation to the kernel's stack and proceeds with the command.
+ */
+export class BindCommand {
+    command;
+    next;
+    name = "BIND";
+    constructor(command, next) {
+        this.command = command;
+        this.next = next;
+    }
+    execute(kernel) {
+        kernel.pushContinuation(this.next);
+        return this.command;
+    }
+    createTraceEntry() { }
+}
+/**
+ * Commands the Kernel to handle multiple branches of execution (non-determinism).
+ * It will try the first one and save the others as choice points.
+ */
+export class ChoiceCommand {
+    alternatives;
+    name = "CHOICE";
+    constructor(alternatives) {
+        this.alternatives = alternatives;
+    }
+    execute(kernel) {
+        return kernel.handleChoice(this.alternatives);
+    }
+    createTraceEntry() { }
+}
+/**
+ * Commands the Kernel to halt execution due to an error.
+ */
+export class FailCommand {
+    error;
+    name = "FAIL";
+    constructor(error) {
+        this.error = error;
+    }
+    execute(kernel) {
+        throw kernel.buildSemanticError(this.error);
+    }
+    createTraceEntry() { }
+}
+// error handling commands
+export class RaiseCommand {
+    exceptionObj;
+    name = "RAISE";
+    constructor(exceptionObj) {
+        this.exceptionObj = exceptionObj;
+    }
+    execute(kernel) {
+        // Le decimos al kernel que inicie el proceso de desapilado para buscar un Catch
+        return kernel.handleRaise(this.exceptionObj);
+    }
+    createTraceEntry() { }
+}
+export class CatchCommand {
+    handler;
+    innerCommand;
+    name = "CATCH";
+    constructor(handler, innerCommand // El cuerpo del try
+    ) {
+        this.handler = handler;
+        this.innerCommand = innerCommand;
+    }
+    execute(kernel) {
+        // 1. Registramos este manejador de errores en el Kernel
+        kernel.pushCatchHandler(this.handler);
+        // 2. Ejecutamos el cuerpo del try envuelto en una limpieza
+        // Si el innerCommand termina con éxito (sin errores), necesitamos sacar el handler de la pila
+        return new BindCommand(this.innerCommand, (result) => {
+            kernel.popCatchHandler(); // Removemos el handler porque no hubo error
+            return new StepCommand(result);
+        });
+    }
+    createTraceEntry() { }
+}
+// Specific commands for LogicRuntime
+/**
+ * Commands the Kernel to stop execution and backtrack due to logical failure.
+ */
+export class BacktrackCommand {
+    name = "BACKTRACK";
+    constructor() { }
+    execute(kernel) {
+        // the backtracking is delegated to the kernel because it manipulates the execution stack
+        return kernel.handleBacktrack();
+    }
+    createTraceEntry() { }
+}
+export class NotCommand {
+    innerGoalCmd;
+    currentSubsts;
+    name = "NOT";
+    constructor(innerGoalCmd, currentSubsts) {
+        this.innerGoalCmd = innerGoalCmd;
+        this.currentSubsts = currentSubsts;
+    }
+    execute(kernel) {
+        const isolatedContext = kernel.evaluator.getContext().clone();
+        const isolatedEvaluator = new InterpreterVisitor(isolatedContext);
+        const isolatedKernel = new YukigoKernel(isolatedEvaluator, "first");
+        // Clone substs to avoid leaking bindings from the inner search
+        const result = isolatedKernel.run(this.innerGoalCmd);
+        if (isLogicResult(result) && result.allSuccessful())
+            return new BacktrackCommand();
+        return new StepCommand(new LogicResult([new LogicAnswer(true, new Map(this.currentSubsts))]));
+    }
+    createTraceEntry() { }
+}
+export class FindallCommand {
+    template;
+    bag;
+    innerGoalCmd;
+    currentSubsts;
+    scope;
+    translator;
+    name = "FINDALL";
+    constructor(template, bag, innerGoalCmd, currentSubsts, scope, translator) {
+        this.template = template;
+        this.bag = bag;
+        this.innerGoalCmd = innerGoalCmd;
+        this.currentSubsts = currentSubsts;
+        this.scope = scope;
+        this.translator = translator;
+    }
+    execute(kernel) {
+        // we need to _find all_ (jaja lol) successful branches
+        const isolatedContext = kernel.evaluator.getContext().clone();
+        const isolatedEvaluator = new InterpreterVisitor(isolatedContext);
+        const isolatedKernel = new YukigoKernel(isolatedEvaluator, "all");
+        // run inner goal - it will return an array of LogicResult if successful
+        const results = isolatedKernel.run(this.innerGoalCmd);
+        const gathered = [];
+        if (Array.isArray(results)) {
+            for (const res of results) {
+                if (isLogicResult(res) && res.allSuccessful()) {
+                    // then we extract all solutions and instantiate the template
+                    res.getSuccessfulSolutions().forEach((solutionEnv) => {
+                        const templateTerm = this.translator.patternToTerm(this.template, this.scope);
+                        gathered.push(templateTerm.instantiate(solutionEnv));
+                    });
+                }
+            }
+        }
+        // then we build a logic list
+        const resultList = new ListTerm(gathered);
+        const bagTerm = this.translator.patternToTerm(this.bag, this.scope);
+        // then we try to unify the list with the bag
+        const finalSubsts = new Map(this.currentSubsts);
+        if (bagTerm.unify(resultList, finalSubsts))
+            return new StepCommand(new LogicResult([new LogicAnswer(true, finalSubsts)]));
+        // finally if unification fails, findall fails
+        return new BacktrackCommand();
+    }
+    createTraceEntry() { }
+}

package/dist/interpreter/components/kernel/index.d.ts

@@ -0,0 +1,51 @@
+import { CatchHandler, Continuation, ExecutionCommand } from "./commands.js";
+import { EnvStack } from "../../utils.js";
+import { InterpreterError } from "../../errors.js";
+import { YuValue } from "../../primitives/index.js";
+import { Evaluator } from "../evaluators/BaseEvaluator.js";
+export type LogicSearchMode = "first" | "all" | "stream";
+export interface ChoicePoint {
+    alternatives: ExecutionCommand[];
+    continuationStack: Continuation[];
+    envSnapshot: EnvStack;
+}
+export declare class YukigoKernel {
+    readonly evaluator: Evaluator;
+    private readonly mode;
+    readonly kid: number;
+    private logicalTrace;
+    private continuationStack;
+    private choiceStack;
+    private finalResult;
+    private searchExhausted;
+    private catchHandlerStack;
+    constructor(evaluator: Evaluator, mode?: LogicSearchMode);
+    /**
+     * Pushes a continuation to the logical stack.
+     */
+    pushContinuation(cont: Continuation): void;
+    /**
+     * Pops a continuation from the stack and executes it with the provided value.
+     * If the stack is empty, sets the final result.
+     */
+    popAndExecute(value: YuValue): ExecutionCommand | void;
+    pushCatchHandler(handler: CatchHandler): void;
+    popCatchHandler(): CatchHandler | undefined;
+    /**
+     * Handles RaiseCommand.
+     */
+    handleRaise(exception: YuValue | InterpreterError): ExecutionCommand | void;
+    /**
+     * Handles a choice point by trying the first alternative and saving the others.
+     */
+    handleChoice(alternatives: ExecutionCommand[]): ExecutionCommand | void;
+    /**
+     * Attempts to backtrack to the last saved choice point.
+     */
+    handleBacktrack(): ExecutionCommand;
+    run(initialCommand: ExecutionCommand): any;
+    private executionStream;
+    getLogicalTrace(): ExecutionCommand[];
+    buildSemanticError(baseError: Error): Error;
+    private getStackFromTrace;
+}

package/dist/interpreter/components/kernel/index.js

@@ -0,0 +1,176 @@
+import { boolean } from "../../utils.js";
+import { InterpreterError } from "../../errors.js";
+import { YuNil } from "../../primitives/index.js";
+export class YukigoKernel {
+    evaluator;
+    mode;
+    kid = Math.floor(Math.random() * 9999);
+    logicalTrace = [];
+    continuationStack = [];
+    choiceStack = [];
+    finalResult;
+    searchExhausted = false;
+    catchHandlerStack = [];
+    constructor(evaluator, mode = "first") {
+        this.evaluator = evaluator;
+        this.mode = mode;
+    }
+    /**
+     * Pushes a continuation to the logical stack.
+     */
+    pushContinuation(cont) {
+        this.continuationStack.push(cont);
+    }
+    /**
+     * Pops a continuation from the stack and executes it with the provided value.
+     * If the stack is empty, sets the final result.
+     */
+    popAndExecute(value) {
+        const next = this.continuationStack.pop();
+        if (!next) {
+            this.finalResult = value;
+            return;
+        }
+        return next(value);
+    }
+    pushCatchHandler(handler) {
+        // Save current continuation stack length so we know where to unwind if an error is raised inside the try block
+        this.catchHandlerStack.push({
+            handler,
+            continuationDepth: this.continuationStack.length,
+        });
+    }
+    popCatchHandler() {
+        const entry = this.catchHandlerStack.pop();
+        return entry?.handler;
+    }
+    /**
+     * Handles RaiseCommand.
+     */
+    handleRaise(exception) {
+        const entry = this.catchHandlerStack.pop();
+        if (!entry) {
+            // if no catch found, we have no other option than to throw the error and break the flow.
+            if (exception instanceof InterpreterError) {
+                throw this.buildSemanticError(exception);
+            }
+            else {
+                // TODO: I think this if-else is unnecessary
+                throw this.buildSemanticError(new InterpreterError("UncaughtException", String(exception)));
+            }
+        }
+        // Unwind continuation stack to the point where the try block was entered
+        this.continuationStack.length = entry.continuationDepth;
+        return entry.handler(exception);
+    }
+    /**
+     * Handles a choice point by trying the first alternative and saving the others.
+     */
+    handleChoice(alternatives) {
+        if (alternatives.length === 0)
+            return this.handleBacktrack();
+        const [first, ...rest] = alternatives;
+        if (rest.length > 0) {
+            this.choiceStack.push({
+                alternatives: rest,
+                continuationStack: [...this.continuationStack],
+                envSnapshot: this.evaluator.getContext().cloneEnv(),
+            });
+        }
+        return first;
+    }
+    /**
+     * Attempts to backtrack to the last saved choice point.
+     */
+    handleBacktrack() {
+        const lastChoice = this.choiceStack.pop();
+        if (!lastChoice) {
+            // logic tree is empty sooo
+            this.searchExhausted = true;
+            this.continuationStack = [];
+            return boolean(false);
+        }
+        this.searchExhausted = false;
+        // clones the stack and environment
+        this.continuationStack = [...lastChoice.continuationStack];
+        const clonedEnv = this.evaluator
+            .getContext()
+            .cloneEnv(lastChoice.envSnapshot);
+        this.evaluator.getContext().setEnv(clonedEnv);
+        const [next, ...remaining] = lastChoice.alternatives;
+        if (remaining.length > 0) {
+            this.choiceStack.push({
+                ...lastChoice,
+                alternatives: remaining,
+            });
+        }
+        return next;
+    }
+    // TODO: remove this f- any
+    run(initialCommand) {
+        const stream = this.executionStream(initialCommand);
+        switch (this.mode) {
+            case "stream":
+                return stream;
+            case "first":
+                const result = stream.next();
+                return result.done ? undefined : result.value;
+            case "all":
+                return Array.from(stream);
+            default:
+                throw new Error(`Output mode "${this.mode}" not supported.`);
+        }
+    }
+    *executionStream(initialCommand) {
+        let current = initialCommand;
+        this.searchExhausted = false;
+        let steps = 0;
+        while (current) {
+            steps++;
+            this.logicalTrace.push(current);
+            // cleans the older traces to avoid consuming memory
+            if (this.logicalTrace.length > 50)
+                this.logicalTrace.shift();
+            current = current.execute(this);
+            if (!current) {
+                if (this.searchExhausted)
+                    break;
+                yield this.finalResult || YuNil.getInstance();
+                current = this.handleBacktrack();
+            }
+        }
+    }
+    getLogicalTrace() {
+        return this.logicalTrace;
+    }
+    buildSemanticError(baseError) {
+        if (baseError.constructor.name === "FailedAssert")
+            return baseError;
+        const frames = this.getStackFromTrace();
+        if (baseError instanceof InterpreterError) {
+            if (baseError.frames.length === 0) {
+                frames.forEach((f) => baseError.pushFrame(f));
+            }
+            return baseError;
+        }
+        const newErr = new InterpreterError("Yukigo VM Error", baseError.message);
+        frames.forEach((f) => newErr.pushFrame(f));
+        return newErr;
+    }
+    getStackFromTrace() {
+        const frames = [];
+        let index = this.logicalTrace.length - 1;
+        // loops through logicalTrace and collects traces
+        for (index; index >= 0; index--) {
+            const cmd = this.logicalTrace[index];
+            const trace = cmd.createTraceEntry();
+            // not all commands leave traces
+            if (!trace)
+                continue;
+            frames.push(trace.frame);
+            if (frames.length >= 10)
+                break;
+        }
+        return frames;
+    }
+}

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

@@ -1,29 +1,32 @@
-import { Exist, Expression, Findall, Forall, Goal, PrimitiveValue, Query, Statement, Not } from "yukigo-ast";
-import { ExpressionEvaluator } from "../../utils.js";
-import { Continuation, Thunk } from "../../trampoline.js";
-import { RuntimeContext, LogicSearchMode } from "../RuntimeContext.js";
-export type LogicExecutable = Expression | Statement | Goal | Exist | Findall;
+import { Exist, Expression, Findall, Forall, Goal, Query, Statement, Not, Assert, Call, If } from "yukigo-ast";
+import { RuntimeContext } from "../RuntimeContext.js";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { VariableTerm } from "./LogicTerm.js";
+import { Substitution } from "../../primitives/index.js";
+import { Evaluator } from "../evaluators/BaseEvaluator.js";
+export type LogicExecutable = Expression | Statement | Goal | Exist | Findall | Forall | Not | Assert | Call | If;
+export type Scope = Map<string, VariableTerm>;
 export declare class LogicEngine {
     private context;
     private translator;
-    constructor(evaluator: ExpressionEvaluator, context: RuntimeContext);
-    unifyExpr(left: Expression, right: Expression, k: Continuation<PrimitiveValue>): Thunk<PrimitiveValue>;
-    solveQuery(node: Query, k: Continuation<PrimitiveValue>, modeOverride?: LogicSearchMode): Thunk<PrimitiveValue>;
-    solveGoal(node: Goal, k: Continuation<PrimitiveValue>, modeOverride?: LogicSearchMode): Thunk<PrimitiveValue>;
-    solveNot(node: Not, k: Continuation<PrimitiveValue>): Thunk<PrimitiveValue>;
-    solveFindall(node: Findall, k: Continuation<PrimitiveValue>): Thunk<PrimitiveValue>;
-    solveForall(node: Forall, k: Continuation<PrimitiveValue>): Thunk<any>;
-    solveExist(node: Exist, k: Continuation<PrimitiveValue>, modeOverride?: LogicSearchMode): Thunk<PrimitiveValue>;
-    private solveConjunction;
-    private solveSingle;
-    private solveLogicGoal;
+    private readonly dispatch;
+    constructor(evaluator: Evaluator, context: RuntimeContext);
+    private buildDispatch;
+    unifyExpr(left: Expression, right: Expression, substs?: Substitution, scope?: Scope): ExecutionCommand;
+    solveQuery(node: Query): ExecutionCommand;
+    solveGoalLike(node: Goal | Exist, outerSubsts?: Substitution, outerScope?: Scope): ExecutionCommand;
+    solveNot(node: Not, substs?: Substitution, scope?: Scope): ExecutionCommand;
+    solveFindall(node: Findall, substs?: Substitution, scope?: Scope): ExecutionCommand;
+    private solveAssign;
+    solveForall(node: Forall, substs?: Substitution, scope?: Scope): ExecutionCommand;
+    private aggregateResults;
+    private branchSolutions;
+    solveConjunction(nodes: LogicExecutable[], substs: Substitution, scope?: Scope): ExecutionCommand;
     private solveCondition;
-    private isLogicGoal;
     private createLocalEnv;
-    private prepareLogicTargetCPS;
-    private collectAllResults;
-    private collectAllResultsForGoal;
-    private createLazyStream;
-    private createLazyStreamForGoal;
-    private formatLogicResult;
+    private finalizeUserResult;
+    private resolveTerms;
+    private resolveArgSequentially;
+    private runKernel;
+    private solveIf;
 }