yukigo 0.2.0 → 0.2.2

package/dist/src/interpreter/components/Visitor.js

@@ -0,0 +1,638 @@
+import { SymbolPrimitive, VariablePattern, Application, UnguardedBody, Sequence, Return, Generator as YuGenerator, isRuntimeObject, isRuntimeClass, Super, isRuntimeFunction, isLazyList, } from "yukigo-ast";
+import { ArithmeticBinaryTable, ArithmeticUnaryTable, BitwiseBinaryTable, BitwiseUnaryTable, ComparisonOperationTable, ListBinaryTable, ListUnaryTable, LogicalBinaryTable, LogicalUnaryTable, StringOperationTable, } from "./Operations.js";
+import { LogicEngine } from "./logic/LogicEngine.js";
+import { InterpreterError, UnexpectedValue } from "../errors.js";
+import { EnvBuilderVisitor } from "./EnvBuilder.js";
+import { FailedAssert, TestRunner } from "./TestRunner.js";
+import { idContinuation, trampoline, valueToCPS, } from "../trampoline.js";
+import { RuntimeContext } from "./RuntimeContext.js";
+import { UnexpectedNode } from "../../utils/helpers.js";
+export class InterpreterVisitor {
+    context;
+    frames;
+    constructor(context, frames = []) {
+        this.context = context;
+        this.frames = frames;
+    }
+    evaluate(node, cont) {
+        return () => {
+            try {
+                const cpsThunk = node.accept(this);
+                return cpsThunk(cont);
+            }
+            catch (err) {
+                if (err instanceof InterpreterError || err instanceof FailedAssert) {
+                    if (err instanceof InterpreterError) {
+                        err.pushFrame({ nodeType: node.constructor.name, loc: node.loc });
+                    }
+                    throw err;
+                }
+                throw new InterpreterError(node.constructor.name, err.message, [...this.frames, { nodeType: node.constructor.name, loc: node.loc }]);
+            }
+        };
+    }
+    visitSequence(node) {
+        return (k) => {
+            if (node.statements.length === 0)
+                return k(undefined);
+            if (this.context.config.debug)
+                console.log(`[Interpreter] Entering sequence with ${node.statements.length} statements`);
+            const evaluateNext = (index, lastResult) => {
+                if (index >= node.statements.length)
+                    return k(lastResult);
+                const stmt = node.statements[index];
+                return this.evaluate(stmt, (result) => {
+                    if (stmt instanceof Return)
+                        return k(result);
+                    return () => evaluateNext(index + 1, result);
+                });
+            };
+            return evaluateNext(0, undefined);
+        };
+    }
+    visitAssert(node) {
+        if (this.context.config.debug) {
+            console.log(`[Interpreter] Visiting Assert`);
+        }
+        return (k) => new TestRunner(this, this.context.lazyRuntime).visitAssert(node)((val) => k(val));
+    }
+    visitTest(node) {
+        if (this.context.config.debug) {
+            console.log(`[Interpreter] Visiting Test`);
+        }
+        return (k) => new TestRunner(this, this.context.lazyRuntime).visitTest(node)((val) => k(val));
+    }
+    visitTestGroup(node) {
+        if (this.context.config.debug) {
+            console.log(`[Interpreter] Visiting TestGroup`);
+        }
+        return (k) => new TestRunner(this, this.context.lazyRuntime).visitTestGroup(node)((val) => k(val));
+    }
+    visitNumberPrimitive(node) {
+        return valueToCPS(node.value);
+    }
+    visitBooleanPrimitive(node) {
+        return valueToCPS(node.value);
+    }
+    visitStringPrimitive(node) {
+        return valueToCPS(node.value);
+    }
+    visitListPrimitive(node) {
+        return (k) => {
+            if (node.value.length === 0)
+                return k([]);
+            const results = [];
+            const evaluateNext = (index) => {
+                if (index >= node.value.length)
+                    return k(results);
+                return this.evaluate(node.value[index], (val) => {
+                    results.push(val);
+                    return () => evaluateNext(index + 1);
+                });
+            };
+            return evaluateNext(0);
+        };
+    }
+    visitNilPrimitive(node) {
+        return valueToCPS(node.value);
+    }
+    visitCharPrimitive(node) {
+        return valueToCPS(node.value);
+    }
+    visitSymbolPrimitive(node) {
+        if (this.context.config.debug) {
+            console.log(`[Interpreter] Looking for \`${node.value}\` in the environment`);
+        }
+        try {
+            const val = this.context.lookup(node.value);
+            if (isRuntimeFunction(val) && val.arity === 0) {
+                if (this.context.config.debug) {
+                    console.log(`[Interpreter] Resolved symbol \`${node.value}\` as arity-0 function, applying...`);
+                }
+                return (k) => () => this.context.funcRuntime.apply(val, [], k);
+            }
+            if (this.context.config.debug) {
+                console.log(`[Interpreter] Found \`${node.value}\`: ${val && typeof val === "object" && "type" in val ? val.type : val}`);
+            }
+            return valueToCPS(val);
+        }
+        catch (error) {
+            throw new InterpreterError("Symbol Lookup", error.message, this.frames);
+        }
+    }
+    visitVariable(node) {
+        const name = node.identifier.value;
+        if (this.context.config.debug) {
+            console.log(`[Interpreter] Defining variable: ${name}`);
+        }
+        return (k) => this.evaluate(node.expression, (value) => {
+            this.context.define(name, value);
+            return k(true);
+        });
+    }
+    visitAssignment(node) {
+        if (!this.context.config.mutability) {
+            throw new InterpreterError("Assignment", `Cannot reassign variable '${node.identifier.value}': mutability is disabled`, this.frames);
+        }
+        const name = node.identifier.value;
+        if (this.context.config.debug) {
+            console.log(`[Interpreter] Assigning variable: ${name}`);
+        }
+        return (k) => this.evaluate(node.expression, (value) => {
+            const onReplace = (scope) => {
+                if (scope.has("self")) {
+                    const self = scope.get("self");
+                    if (isRuntimeObject(self) && self.fields.has(name))
+                        self.fields.set(name, value);
+                }
+            };
+            if (!this.context.replace(name, value, onReplace))
+                throw new InterpreterError("Assignment", `Cannot assign to undefined variable: ${name}`, this.frames);
+            return k(value);
+        });
+    }
+    visitArithmeticUnaryOperation(node) {
+        return this.processUnary(node, ArithmeticUnaryTable, (a) => !Number.isNaN(a), "ArithmeticUnaryOperation");
+    }
+    visitArithmeticBinaryOperation(node) {
+        return this.processBinary(node, ArithmeticBinaryTable, (a, b) => typeof a === "number" && typeof b === "number", "ArithmeticBinaryOperation");
+    }
+    visitListUnaryOperation(node) {
+        return (k) => this.evaluate(node.operand, (operand) => {
+            if (typeof operand !== "string" &&
+                !Array.isArray(operand) &&
+                !isLazyList(operand))
+                throw new UnexpectedValue("ListUnaryOperation", "Array, String or LazyList", typeof operand);
+            return this.context.lazyRuntime.realizeList(operand, (arr) => {
+                const fn = ListUnaryTable[node.operator];
+                if (!fn)
+                    throw new InterpreterError("ListUnaryOperation", `Unknown operator: ${node.operator}`);
+                return k(fn(arr));
+            });
+        });
+    }
+    visitListBinaryOperation(node) {
+        if (node.operator === "Concat") {
+            if (this.context.config.lazyLoading) {
+                return (k) => this.context.lazyRuntime.evaluateConcatLazy(node, this, k);
+            }
+            return (k) => this.evaluate(node.left, (left) => {
+                return () => this.evaluate(node.right, (right) => {
+                    return this.context.lazyRuntime.evaluateConcat(left, right, k);
+                });
+            });
+        }
+        return this.processBinary(node, ListBinaryTable, (a, b) => (Array.isArray(a) || typeof a === "string" || isLazyList(a)) &&
+            (Array.isArray(b) || typeof b === "string" || isLazyList(b)), "ListBinaryOperation");
+    }
+    visitComparisonOperation(node) {
+        if (node.operator === "Equal" || node.operator === "NotEqual") {
+            return (k) => this.evaluate(node.left, (left) => () => this.evaluate(node.right, (right) => this.context.lazyRuntime.deepEqual(left, right, (eq) => k(node.operator === "Equal" ? eq : !eq))));
+        }
+        return this.processBinary(node, ComparisonOperationTable, () => true, "ComparisonOperation");
+    }
+    visitLogicalBinaryOperation(node) {
+        return (k) => this.evaluate(node.left, (left) => {
+            if (typeof left !== "boolean")
+                throw new InterpreterError("LogicalBinaryOperation", `Expected left side to be boolean and got: ${left}`);
+            const fn = LogicalBinaryTable[node.operator];
+            if (!fn)
+                throw new InterpreterError("LogicalBinaryOperation", `Unknown operator '${node.operator}'`);
+            if (this.context.config.lazyLoading) {
+                if (node.operator === "And" && left === false)
+                    return k(false);
+                if (node.operator === "Or" && left === true)
+                    return k(true);
+            }
+            return this.evaluate(node.right, (right) => {
+                if (typeof right !== "boolean")
+                    throw new InterpreterError("LogicalBinaryOperation", `Expected right side to be boolean and got: ${right}`);
+                return k(fn(left, () => right));
+            });
+        });
+    }
+    visitLogicalUnaryOperation(node) {
+        return this.processUnary(node, LogicalUnaryTable, (a) => typeof a === "boolean", "LogicalUnaryOperation");
+    }
+    visitBitwiseBinaryOperation(node) {
+        return this.processBinary(node, BitwiseBinaryTable, (a, b) => !Number.isNaN(a) && !Number.isNaN(b), "BitwiseBinaryOperation");
+    }
+    visitBitwiseUnaryOperation(node) {
+        return this.processUnary(node, BitwiseUnaryTable, (a) => !Number.isNaN(a), "BitwiseUnaryOperation");
+    }
+    visitStringOperation(node) {
+        return this.processBinary(node, StringOperationTable, (a, b) => typeof a === "string" || typeof b === "string", "StringOperation");
+    }
+    visitUnifyOperation(node) {
+        return (k) => this.getLogicEngine().unifyExpr(node.left, node.right, k);
+    }
+    visitAssignOperation(node) {
+        if (!this.context.config.mutability) {
+            throw new InterpreterError("AssignOperation", `Cannot perform assignment operation: mutability is disabled`, this.frames);
+        }
+        if (!(node.left instanceof SymbolPrimitive))
+            throw new InterpreterError("AssignOperation", "Left side must be a SymbolPrimitive");
+        const name = node.left.value;
+        return (k) => this.evaluate(node.right, (value) => {
+            const onReplace = (scope) => {
+                if (scope.has("self")) {
+                    const self = scope.get("self");
+                    if (isRuntimeObject(self) && self.fields.has(name)) {
+                        self.fields.set(name, value);
+                    }
+                }
+            };
+            if (!this.context.replace(name, value, onReplace)) {
+                this.context.define(name, value);
+            }
+            return k(true);
+        });
+    }
+    visitTupleExpr(node) {
+        return (k) => {
+            const results = [];
+            const evaluateNext = (index) => {
+                if (index >= node.elements.length)
+                    return k(results);
+                return this.evaluate(node.elements[index], (val) => {
+                    results.push(val);
+                    return () => evaluateNext(index + 1);
+                });
+            };
+            return evaluateNext(0);
+        };
+    }
+    visitFieldExpression(node) {
+        return (k) => this.evaluate(node.name, (obj) => {
+            return k(this.context.objRuntime.getField(obj, node.name.value));
+        });
+    }
+    visitDataExpr(node) {
+        return (k) => {
+            const fieldValues = new Map();
+            const evaluateFields = (index) => {
+                if (index >= node.contents.length) {
+                    return k(this.context.objRuntime.instantiate(node.name.value, node.name.value, fieldValues, new Map()));
+                }
+                const field = node.contents[index];
+                return this.evaluate(field.expression, (value) => {
+                    fieldValues.set(field.name.value, value);
+                    return () => evaluateFields(index + 1);
+                });
+            };
+            return evaluateFields(0);
+        };
+    }
+    visitConsExpr(node) {
+        return (k) => this.context.lazyRuntime.evaluateCons(node, this, k);
+    }
+    visitLetInExpr(node) {
+        return (k) => {
+            const oldEnv = this.context.env;
+            this.context.pushEnv();
+            const envBuilder = new EnvBuilderVisitor(this.context);
+            node.declarations.accept(envBuilder);
+            return this.evaluate(node.expression, (result) => {
+                this.context.env = oldEnv;
+                return k(result);
+            });
+        };
+    }
+    visitIf(node) {
+        return (k) => this.evaluate(node.condition, (condition) => {
+            if (typeof condition !== "boolean")
+                throw new InterpreterError("If", `Expected boolean in condition and got ${typeof condition}`, this.frames);
+            if (this.context.config.debug) {
+                console.log(`[Interpreter] If condition: ${condition}`);
+            }
+            return condition
+                ? node.then.accept(this)(k)
+                : node.elseExpr.accept(this)(k);
+        });
+    }
+    visitCall(node) {
+        return (k) => this.evaluate(node.callee, (callee) => {
+            const args = [];
+            const evaluateArgs = (index) => {
+                if (index < node.args.length)
+                    return this.evaluate(node.args[index], (val) => {
+                        args.push(val);
+                        return () => evaluateArgs(index + 1);
+                    });
+                if (!isRuntimeFunction(callee))
+                    throw new InterpreterError("Call", "Target is not a function");
+                if (this.context.config.debug)
+                    console.log(`[Interpreter] Calling function: ${callee.identifier} with ${args.length} args`);
+                return this.context.funcRuntime.apply(callee, args, k);
+            };
+            return evaluateArgs(0);
+        });
+    }
+    visitOtherwise(node) {
+        return valueToCPS(true);
+    }
+    visitCompositionExpression(node) {
+        return (k) => this.evaluate(node.left, (f) => {
+            return this.evaluate(node.right, (g) => {
+                if (!isRuntimeFunction(f) || !isRuntimeFunction(g)) {
+                    throw new InterpreterError("Composition", "Both operands of (.) must be functions");
+                }
+                const F_REF = "__internal_f";
+                const G_REF = "__internal_g";
+                const PARAM_NAME = "__x";
+                const compositionBody = new Application(new SymbolPrimitive(F_REF), new Application(new SymbolPrimitive(G_REF), new SymbolPrimitive(PARAM_NAME)));
+                const patterns = [
+                    new VariablePattern(new SymbolPrimitive(PARAM_NAME)),
+                ];
+                const equation = {
+                    patterns,
+                    body: new UnguardedBody(new Sequence([new Return(compositionBody)])),
+                };
+                const privateScope = new Map();
+                privateScope.set(F_REF, f);
+                privateScope.set(G_REF, g);
+                const capturedEnv = {
+                    head: privateScope,
+                    tail: this.context.env,
+                };
+                return k({
+                    type: "Function",
+                    arity: 1,
+                    identifier: `<(${f.identifier} . ${g.identifier})>`,
+                    equations: [equation],
+                    pendingArgs: [],
+                    closure: capturedEnv,
+                });
+            });
+        });
+    }
+    visitLambda(node) {
+        const patterns = node.parameters;
+        const equation = {
+            patterns,
+            body: new UnguardedBody(new Sequence([new Return(node.body)])),
+        };
+        return valueToCPS({
+            type: "Function",
+            arity: patterns.length,
+            equations: [equation],
+            pendingArgs: [],
+            identifier: "<lambda>",
+            closure: this.context.env,
+        });
+    }
+    visitApplication(node) {
+        const { funcRuntime } = this.context;
+        if (this.context.config.debug) {
+            console.log(`[Interpreter] Visiting Application`);
+        }
+        return (k) => this.evaluate(node.functionExpr, (func) => {
+            if (!isRuntimeFunction(func))
+                throw new InterpreterError("Application", "Cannot apply non-function");
+            const applyFuncToNode = (func) => (k) => this.evaluate(node.parameter, (arg) => {
+                const argThunk = () => arg;
+                const allPendingArgs = func.pendingArgs
+                    ? [...func.pendingArgs, argThunk]
+                    : [argThunk];
+                return funcRuntime.applyArguments(func, allPendingArgs)(k);
+            });
+            if (func.arity === 0) {
+                return funcRuntime.applyArguments(func, [])((resultOfFunc) => {
+                    if (!isRuntimeFunction(resultOfFunc))
+                        throw new InterpreterError("Application", `Cannot apply non-function result of arity-0 function`);
+                    return applyFuncToNode(resultOfFunc)(k);
+                });
+            }
+            return applyFuncToNode(func)(k);
+        });
+    }
+    visitQuery(node) {
+        if (this.context.config.debug) {
+            console.log(`[Interpreter] Visiting Query.`);
+        }
+        return (k) => this.getLogicEngine().solveQuery(node, (res) => {
+            this.bindLogicResults(res);
+            return k(res);
+        });
+    }
+    visitExist(node) {
+        return (k) => this.getLogicEngine().solveExist(node, (res) => {
+            this.bindLogicResults(res);
+            return k(res);
+        });
+    }
+    visitNot(node) {
+        return (k) => this.getLogicEngine().solveNot(node, k);
+    }
+    visitFindall(node) {
+        return (k) => this.getLogicEngine().solveFindall(node, k);
+    }
+    visitForall(node) {
+        return (k) => this.getLogicEngine().solveForall(node, k);
+    }
+    visitGoal(node) {
+        return (k) => this.getLogicEngine().solveGoal(node, (res) => {
+            this.bindLogicResults(res);
+            return k(res);
+        });
+    }
+    bindLogicResults(res) {
+        if (!res)
+            return;
+        if (Array.isArray(res)) {
+            if (res.length > 0)
+                this.bindLogicResults(res[0]);
+            return;
+        }
+        if (typeof res === "object" &&
+            res !== null &&
+            "success" in res &&
+            res.success &&
+            "solutions" in res) {
+            for (const [name, val] of res.solutions) {
+                this.context.define(name, val);
+            }
+        }
+    }
+    visitLogicConstraint(node) {
+        return (k) => this.evaluate(node.expression, (val) => {
+            if (Array.isArray(val))
+                return k(val.length > 0);
+            return k(!!val);
+        });
+    }
+    visitSuper(node) {
+        let methodName;
+        try {
+            methodName = this.context.lookup("__METHOD_NAME__");
+        }
+        catch (e) {
+            throw new InterpreterError("Super", "'super' keyword used outside of a method context", this.frames);
+        }
+        return (k) => {
+            const args = [];
+            const evaluateNextArg = (index) => {
+                if (index >= node.args.length) {
+                    if (this.context.config.debug) {
+                        console.log(`[Interpreter] Dispatching super call: ${methodName}`);
+                    }
+                    return this.context.objRuntime.dispatchSuper(this.context.env, methodName, args, k);
+                }
+                return this.evaluate(node.args[index], (val) => {
+                    args.push(val);
+                    return () => evaluateNextArg(index + 1);
+                });
+            };
+            return evaluateNextArg(0);
+        };
+    }
+    visitSend(node) {
+        return (k) => {
+            if (node.receiver instanceof Super) {
+                const methodName = node.selector.value;
+                const args = [];
+                const evaluateNextArg = (index) => {
+                    if (index >= node.args.length) {
+                        if (this.context.config.debug) {
+                            console.log(`[Interpreter] Dispatching super call: ${methodName}`);
+                        }
+                        return this.context.objRuntime.dispatchSuper(this.context.env, methodName, args, k);
+                    }
+                    return this.evaluate(node.args[index], (val) => {
+                        args.push(val);
+                        return () => evaluateNextArg(index + 1);
+                    });
+                };
+                return evaluateNextArg(0);
+            }
+            return this.evaluate(node.receiver, (receiver) => {
+                const methodName = node.selector.value;
+                const args = [];
+                const evaluateNextArg = (index) => {
+                    if (index >= node.args.length) {
+                        if (this.context.config.debug) {
+                            console.log(`[Interpreter] Sending method call: ${methodName} to object`);
+                        }
+                        return this.context.objRuntime.dispatch(receiver, methodName, args, this.context.env, k);
+                    }
+                    return this.evaluate(node.args[index], (val) => {
+                        args.push(val);
+                        return () => evaluateNextArg(index + 1);
+                    });
+                };
+                return evaluateNextArg(0);
+            });
+        };
+    }
+    visitNew(node) {
+        const className = node.identifier.value;
+        const classDef = this.context.lookup(className);
+        if (!isRuntimeClass(classDef))
+            throw new InterpreterError("New", `${className} is not a class.`, this.frames);
+        if (this.context.config.debug) {
+            console.log(`[Interpreter] Instantiating class: ${className}`);
+        }
+        return valueToCPS(this.context.objRuntime.instantiate(className, node.identifier.value, classDef.fields, classDef.methods));
+    }
+    visitSelf(node) {
+        try {
+            return valueToCPS(this.context.lookup("self"));
+        }
+        catch {
+            throw new InterpreterError("Self", "'self' is not defined in this context");
+        }
+    }
+    visitListComprehension(node) {
+        return (k) => {
+            const results = [];
+            const process = (index) => {
+                if (index >= node.generators.length) {
+                    return this.evaluate(node.projection, (proj) => {
+                        results.push(proj);
+                        return () => k(results);
+                    });
+                }
+                const current = node.generators[index];
+                if (current instanceof YuGenerator) {
+                    return this.evaluate(current.expression, (exprResult) => {
+                        return this.context.lazyRuntime.realizeList(exprResult, (sourceList) => {
+                            const iterateSource = (sourceIndex) => {
+                                if (sourceIndex >= sourceList.length)
+                                    return () => k(results);
+                                const item = sourceList[sourceIndex];
+                                const varName = current.variable.value;
+                                this.context.define(varName, item);
+                                return () => process(index + 1);
+                            };
+                            return iterateSource(0);
+                        });
+                    });
+                }
+                else {
+                    return this.evaluate(current, (condition) => {
+                        return condition === true
+                            ? () => process(index + 1)
+                            : () => k(results);
+                    });
+                }
+            };
+            this.context.pushEnv();
+            return process(0);
+        };
+    }
+    visitTypeCast(node) {
+        return node.expression.accept(this);
+    }
+    visitGenerator(node) {
+        return (k) => this.evaluate(node.expression, k);
+    }
+    visitRaise(node) {
+        return (k) => this.evaluate(node.body, (msg) => {
+            if (typeof msg !== "string")
+                throw new UnexpectedValue("Raise", "string", typeof msg);
+            throw new InterpreterError("Raise", msg);
+        });
+    }
+    visitRangeExpression(node) {
+        return (k) => this.context.lazyRuntime.evaluateRange(node, this, k);
+    }
+    visit(node) {
+        return node.accept(this);
+    }
+    fallback(node) {
+        throw new UnexpectedNode(node.constructor.name, "InterpreterVisitor");
+    }
+    realizeList(val, k) {
+        return this.context.lazyRuntime.realizeList(val, k);
+    }
+    processBinary(node, table, typeGuard, contextName) {
+        return (k) => this.evaluate(node.left, (left) => {
+            return this.evaluate(node.right, (right) => {
+                if (!typeGuard(left, right))
+                    throw new InterpreterError(contextName, `Type mismatch: ${left}, ${right}`, this.frames);
+                const fn = table[node.operator];
+                if (!fn)
+                    throw new InterpreterError(contextName, `Unknown op: ${node.operator}`);
+                return k(fn(left, right));
+            });
+        });
+    }
+    processUnary(node, table, typeGuard, contextName) {
+        return (k) => this.evaluate(node.operand, (operand) => {
+            if (!typeGuard(operand))
+                throw new InterpreterError(contextName, `Type mismatch: ${operand}`, this.frames);
+            const fn = table[node.operator];
+            if (!fn)
+                throw new InterpreterError(contextName, `Unknown op: ${node.operator}`);
+            return k(fn(operand));
+        });
+    }
+    getLogicEngine() {
+        return new LogicEngine(this, this.context);
+    }
+    static evaluateLiteral(node) {
+        const ctx = new RuntimeContext();
+        const visitor = new InterpreterVisitor(ctx);
+        return trampoline(visitor.evaluate(node, idContinuation));
+    }
+}

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

@@ -0,0 +1,29 @@
+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;
+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 solveCondition;
+    private isLogicGoal;
+    private createLocalEnv;
+    private prepareLogicTargetCPS;
+    private collectAllResults;
+    private collectAllResultsForGoal;
+    private createLazyStream;
+    private createLazyStreamForGoal;
+    private formatLogicResult;
+}