yukigo 0.2.0 → 0.2.2

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

@@ -0,0 +1,358 @@
+import { ConstructorPattern, isLazyList, ListPrimitive, SimpleType, ListType, } from "yukigo-ast";
+import { InterpreterVisitor } from "./Visitor.js";
+import { getYukigoType } from "../utils.js";
+import { UnexpectedNode } from "../../utils/helpers.js";
+class SharedSequence {
+    cache = [];
+    source;
+    isDone = false;
+    constructor(generatorFactory) {
+        this.source = generatorFactory();
+    }
+    get(index) {
+        if (index < this.cache.length)
+            return { value: this.cache[index], done: false };
+        if (this.isDone)
+            return { value: null, done: true };
+        while (this.cache.length <= index) {
+            const next = this.source.next();
+            if (next.done) {
+                this.isDone = true;
+                return { value: null, done: true };
+            }
+            this.cache.push(next.value);
+        }
+        return { value: this.cache[index], done: false };
+    }
+}
+export function isMemoizedList(list) {
+    return (list !== null &&
+        typeof list === "object" &&
+        "type" in list &&
+        "_offset" in list &&
+        "_sequence" in list);
+}
+export function createMemoizedStream(genFactory, sequence, offset = 0) {
+    const seq = sequence ?? new SharedSequence(genFactory);
+    return {
+        type: "LazyList",
+        _sequence: seq,
+        _offset: offset,
+        generator: function* () {
+            let currentIdx = offset;
+            while (true) {
+                const res = seq.get(currentIdx);
+                if (res.done)
+                    return;
+                yield res.value;
+                currentIdx++;
+            }
+        },
+        toJSON() {
+            const iterator = this.generator();
+            const buffer = [];
+            let next = iterator.next();
+            while (!next.done) {
+                buffer.push(next.value);
+                next = iterator.next();
+            }
+            return buffer;
+        },
+    };
+}
+export class PatternResolver {
+    visitVariablePattern(node) {
+        return node.name.value;
+    }
+    visitWildcardPattern(node) {
+        return "_";
+    }
+    visitLiteralPattern(node) {
+        const { name } = node;
+        if (name instanceof ListPrimitive)
+            return String(name.value.map((elem) => elem.accept(this)));
+        return String(name.value);
+    }
+    visitTuplePattern(node) {
+        return String(node.elements.map((elem) => elem.accept(this)));
+    }
+    visitListPattern(node) {
+        const { elements } = node;
+        return elements.length === 0
+            ? "[]"
+            : String(elements.map((elem) => elem.accept(this)));
+    }
+    visitConsPattern(node) {
+        const head = node.left.accept(this);
+        const tail = node.right.accept(this);
+        return `(${head}:${tail})`;
+    }
+    visitConstructorPattern(node) {
+        const constr = node.identifier.value;
+        const args = node.args.map((pat) => pat.accept(this)).join(" ");
+        return `${constr} ${args}`;
+    }
+    visitFunctorPattern(node) {
+        // Same as ConstructorPattern (alias)
+        return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
+    }
+    visitApplicationPattern(node) {
+        // Same as FunctorPattern
+        return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
+    }
+    visitAsPattern(node) {
+        const alias = node.left.accept(this);
+        const pattern = node.right.accept(this);
+        return `${alias}@${pattern}`;
+    }
+    visitTypePattern(node) {
+        const typeStr = node.targetType.toString();
+        return node.innerPattern
+            ? `(${typeStr} ${node.innerPattern.accept(this)})`
+            : typeStr;
+    }
+    visit(node) {
+        return node.accept(this);
+    }
+    fallback(node) {
+        throw new UnexpectedNode(node.constructor.name, "PatternResolver");
+    }
+}
+/**
+ * Recursively matches a value against a pattern node.
+ * Updates `bindings` when variables are bound successfully.
+ * Returns true if the pattern matches, false otherwise.
+ */
+export class PatternMatcher {
+    value;
+    bindings;
+    ctx;
+    constructor(value, bindings, ctx) {
+        this.value = value;
+        this.bindings = bindings;
+        this.ctx = ctx;
+    }
+    visitVariablePattern(node) {
+        return (k) => {
+            this.bindings.push([node.name.value, this.value]);
+            return k(true);
+        };
+    }
+    visitWildcardPattern(node) {
+        return (k) => k(true);
+    }
+    visitLiteralPattern(node) {
+        return (k) => {
+            const literalValue = InterpreterVisitor.evaluateLiteral(node.name);
+            return this.ctx.lazyRuntime.deepEqual(this.value, literalValue, k);
+        };
+    }
+    visitTuplePattern(node) {
+        return (k) => {
+            const processValue = (val) => {
+                if (!Array.isArray(val))
+                    return k(false);
+                if (val.length !== node.elements.length)
+                    return k(false);
+                const matchNext = (index) => {
+                    if (index >= node.elements.length)
+                        return k(true);
+                    const matcher = new PatternMatcher(val[index], this.bindings, this.ctx);
+                    return node.elements[index].accept(matcher)((isMatch) => {
+                        if (!isMatch)
+                            return k(false);
+                        return () => matchNext(index + 1);
+                    });
+                };
+                return matchNext(0);
+            };
+            if (isLazyList(this.value)) {
+                return this.ctx.lazyRuntime.realizeList(this.value, (val) => {
+                    return () => processValue(val);
+                });
+            }
+            return processValue(this.value);
+        };
+    }
+    visitListPattern(node) {
+        return (k) => {
+            const value = this.value;
+            const neededLength = node.elements.length;
+            const finishMatching = (valArr) => {
+                if (valArr.length !== neededLength)
+                    return k(false);
+                return this.matchList(node.elements, valArr, k);
+            };
+            // empty list case
+            if (neededLength === 0) {
+                if (Array.isArray(value) || typeof value === "string")
+                    return k(value.length === 0);
+                if (isLazyList(value)) {
+                    const iter = value.generator();
+                    return k(Boolean(iter.next().done));
+                }
+                return k(false);
+            }
+            if (Array.isArray(value))
+                return finishMatching(value);
+            if (typeof value === "string")
+                return finishMatching(value.split(""));
+            if (isLazyList(value)) {
+                return this.ctx.lazyRuntime.realizeList(value, (valArr) => {
+                    return () => finishMatching(valArr);
+                });
+            }
+            return k(false);
+        };
+    }
+    matchList(elements, value, k) {
+        if (value.length !== elements.length)
+            return k(false);
+        const matchNext = (index) => {
+            if (index >= elements.length)
+                return k(true);
+            const matcher = new PatternMatcher(value[index], this.bindings, this.ctx);
+            return elements[index].accept(matcher)((isMatch) => {
+                if (!isMatch)
+                    return k(false);
+                return () => matchNext(index + 1);
+            });
+        };
+        return matchNext(0);
+    }
+    visitConsPattern(node) {
+        return (k) => {
+            const [head, tail] = this.resolveCons(this.value);
+            if (head === null || tail === null)
+                return k(false);
+            const headMatcher = new PatternMatcher(head, this.bindings, this.ctx);
+            return node.left.accept(headMatcher)((headMatches) => {
+                if (!headMatches)
+                    return k(false);
+                const tailMatcher = new PatternMatcher(tail, this.bindings, this.ctx);
+                return node.right.accept(tailMatcher)(k);
+            });
+        };
+    }
+    visitTypePattern(node) {
+        return (k) => {
+            const actualType = getYukigoType(this.value);
+            let matches = false;
+            const targetType = node.targetType;
+            if (targetType instanceof SimpleType) {
+                matches = targetType.value === actualType;
+            }
+            else if (targetType instanceof ListType) {
+                matches = actualType === "YuList";
+            }
+            if (!matches)
+                return k(false);
+            if (node.innerPattern) {
+                const innerMatcher = new PatternMatcher(this.value, this.bindings, this.ctx);
+                return node.innerPattern.accept(innerMatcher)(k);
+            }
+            return k(true);
+        };
+    }
+    resolveCons(list) {
+        if (Array.isArray(list)) {
+            if (list.length === 0)
+                return [null, null];
+            const isLazy = this.ctx.config.lazyLoading;
+            if (!isLazy)
+                return [list[0], list.slice(1)];
+            const tail = {
+                type: "LazyList",
+                generator: function* () {
+                    for (let i = 1; i < list.length; i++)
+                        yield list[i];
+                },
+            };
+            return [list[0], tail];
+        }
+        if (typeof list === "string") {
+            if (list.length === 0)
+                return [null, null];
+            const isLazy = this.ctx.config.lazyLoading;
+            if (!isLazy)
+                return [list[0], list.slice(1)];
+            const tail = {
+                type: "LazyList",
+                generator: function* () {
+                    for (let i = 1; i < list.length; i++)
+                        yield list[i];
+                },
+            };
+            return [list[0], tail];
+        }
+        // lazy list case
+        if (isLazyList(list)) {
+            let memoList;
+            // optimize, convert to memoized
+            if (isMemoizedList(list)) {
+                memoList = list;
+            }
+            else {
+                memoList = createMemoizedStream(list.generator);
+            }
+            const currentRes = memoList._sequence.get(memoList._offset);
+            if (currentRes.done)
+                return [null, null];
+            const tail = createMemoizedStream(list.generator, memoList._sequence, memoList._offset + 1);
+            return [currentRes.value, tail];
+        }
+        return [null, null];
+    }
+    visitConstructorPattern(node) {
+        return (k) => {
+            if (!Array.isArray(this.value) || this.value.length === 0)
+                return k(false);
+            if (this.value[0] !== node.identifier.value)
+                return k(false);
+            const args = this.value.slice(1);
+            return this.matchList(node.args, args, k);
+        };
+    }
+    visitFunctorPattern(node) {
+        return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
+    }
+    visitApplicationPattern(node) {
+        return this.visitConstructorPattern(new ConstructorPattern(node.identifier, node.args));
+    }
+    visitAsPattern(node) {
+        return (k) => {
+            const innerMatcher = new PatternMatcher(this.value, this.bindings, this.ctx);
+            return node.right.accept(innerMatcher)((innerMatches) => {
+                if (!innerMatches)
+                    return k(false);
+                const aliasMatcher = new PatternMatcher(this.value, this.bindings, this.ctx);
+                return node.left.accept(aliasMatcher)(k);
+            });
+        };
+    }
+    visitUnionPattern(node) {
+        return (k) => {
+            const tryNext = (index) => {
+                if (index >= node.elements.length)
+                    return k(false);
+                const pattern = node.elements[index];
+                const trialBindings = [];
+                const matcher = new PatternMatcher(this.value, trialBindings, this.ctx);
+                return pattern.accept(matcher)((isMatch) => {
+                    if (isMatch) {
+                        this.bindings.push(...trialBindings);
+                        return k(true);
+                    }
+                    return () => tryNext(index + 1);
+                });
+            };
+            return tryNext(0);
+        };
+    }
+    visit(node) {
+        return node.accept(this);
+    }
+    fallback(node) {
+        throw new UnexpectedNode(node.constructor.name, "PatternMatcher");
+    }
+}

package/dist/src/interpreter/components/RuntimeContext.d.ts

@@ -0,0 +1,35 @@
+import { Environment, EnvStack, PrimitiveValue } from "yukigo-ast";
+import { FunctionRuntime } from "./runtimes/FunctionRuntime.js";
+import { LazyRuntime } from "./runtimes/LazyRuntime.js";
+import { ObjectRuntime } from "./runtimes/ObjectRuntime.js";
+export declare const DefaultConfiguration: Required<InterpreterConfig>;
+export type LogicSearchMode = "first" | "all" | "stream";
+export interface InterpreterConfig {
+    lazyLoading?: boolean;
+    debug?: boolean;
+    outputMode?: LogicSearchMode;
+    mutability?: boolean;
+}
+export declare class UninitializedConfig extends Error {
+    constructor();
+}
+export declare class ReinitializedConfig extends Error {
+    constructor();
+}
+export declare class RuntimeContext {
+    readonly config: InterpreterConfig;
+    env: EnvStack;
+    lazyRuntime: LazyRuntime;
+    funcRuntime: FunctionRuntime;
+    objRuntime: ObjectRuntime;
+    constructor(config?: InterpreterConfig);
+    setEnv(env: EnvStack): void;
+    isDefined(name: string): boolean;
+    pushEnv(frame?: Environment): void;
+    replace(name: string, value: PrimitiveValue, onReplace?: (env: Environment) => void): boolean;
+    popEnv(): void;
+    lookup(name: string): PrimitiveValue;
+    remove(name: string): void;
+    define(name: string, value: PrimitiveValue): void;
+    clone(env?: EnvStack): EnvStack;
+}

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

@@ -0,0 +1,93 @@
+import { FunctionRuntime } from "./runtimes/FunctionRuntime.js";
+import { LazyRuntime } from "./runtimes/LazyRuntime.js";
+import { ObjectRuntime } from "./runtimes/ObjectRuntime.js";
+import { createGlobalEnv } from "../utils.js";
+import { UnboundVariable } from "../errors.js";
+export const DefaultConfiguration = {
+    lazyLoading: false,
+    debug: false,
+    outputMode: "first",
+    mutability: true,
+};
+export class UninitializedConfig extends Error {
+    constructor() {
+        super("GlobalConfig was not initialized. You must call initialize() first.");
+    }
+}
+export class ReinitializedConfig extends Error {
+    constructor() {
+        super("GlobalConfig is already initialized. You cannot change it at execution.");
+    }
+}
+export class RuntimeContext {
+    config = DefaultConfiguration;
+    env;
+    lazyRuntime;
+    funcRuntime;
+    objRuntime;
+    constructor(config) {
+        this.config = Object.freeze({ ...DefaultConfiguration, ...config });
+        this.lazyRuntime = new LazyRuntime(this);
+        this.funcRuntime = new FunctionRuntime(this);
+        this.objRuntime = new ObjectRuntime(this);
+        this.env = createGlobalEnv();
+    }
+    setEnv(env) {
+        this.env = env;
+    }
+    isDefined(name) {
+        let current = this.env;
+        while (current !== null) {
+            if (current.head.has(name))
+                return true;
+            current = current.tail;
+        }
+        return false;
+    }
+    pushEnv(frame = new Map()) {
+        this.env = {
+            head: frame,
+            tail: this.env,
+        };
+    }
+    replace(name, value, onReplace) {
+        let current = this.env;
+        while (current !== null) {
+            if (current.head.has(name)) {
+                current.head.set(name, value);
+                if (onReplace)
+                    onReplace(current.head);
+                return true;
+            }
+            current = current.tail;
+        }
+        return false;
+    }
+    popEnv() {
+        if (!this.env.tail)
+            throw new Error("Runtime Error: Cannot pop the global environment scope.");
+        this.env = this.env.tail;
+    }
+    lookup(name) {
+        let current = this.env;
+        while (current !== null) {
+            if (current.head.has(name))
+                return current.head.get(name);
+            current = current.tail;
+        }
+        throw new UnboundVariable(name);
+    }
+    remove(name) {
+        this.env.head.delete(name);
+    }
+    define(name, value) {
+        this.env.head.set(name, value);
+    }
+    clone(env) {
+        const target = env ?? this.env;
+        return {
+            head: new Map(target.head),
+            tail: this.env.tail,
+        };
+    }
+}

package/dist/src/interpreter/components/TestRunner.d.ts

@@ -0,0 +1,19 @@
+import { Assert, ASTNode, PrimitiveValue, Test, TestGroup, TraverseVisitor } from "yukigo-ast";
+import { InterpreterVisitor } from "./Visitor.js";
+import { CPSThunk } from "../trampoline.js";
+import { LazyRuntime } from "./runtimes/LazyRuntime.js";
+export declare class FailedAssert extends Error {
+    actual?: PrimitiveValue;
+    expected?: PrimitiveValue;
+    constructor(actual?: PrimitiveValue, expected?: PrimitiveValue, message?: string);
+}
+export declare class TestRunner extends TraverseVisitor {
+    interpreter: InterpreterVisitor;
+    private lazyRuntime;
+    constructor(interpreter: InterpreterVisitor, lazyRuntime: LazyRuntime);
+    run(node: TestGroup | Test | Assert): CPSThunk<void>;
+    visitTestGroup(node: TestGroup): CPSThunk<void>;
+    visitTest(node: Test): CPSThunk<void>;
+    visitAssert(node: Assert): CPSThunk<void>;
+    fallback(node: ASTNode): CPSThunk<PrimitiveValue>;
+}

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

@@ -0,0 +1,110 @@
+import { TraverseVisitor, } from "yukigo-ast";
+import { idContinuation, trampoline, } from "../trampoline.js";
+import { UnexpectedNode } from "../../utils/helpers.js";
+export class FailedAssert extends Error {
+    actual;
+    expected;
+    constructor(actual, expected, message) {
+        super(message || `Assertion failed: expected ${expected}, got ${actual}`);
+        this.actual = actual;
+        this.expected = expected;
+        this.name = "FailedAssert";
+    }
+}
+class AssertionVisitor extends TraverseVisitor {
+    interpreter;
+    negated;
+    lazyRuntime;
+    constructor(interpreter, negated, lazyRuntime) {
+        super();
+        this.interpreter = interpreter;
+        this.negated = negated;
+        this.lazyRuntime = lazyRuntime;
+    }
+    visitFailure(node) {
+        return (k) => () => {
+            let threw = false;
+            let actualError;
+            try {
+                // We use trampoline here to execute the function under test.
+                // While this is a nested trampoline, it's necessary to capture the error
+                // and isolate the test execution from the test runner's CPS flow.
+                trampoline(this.interpreter.evaluate(node.func, idContinuation));
+            }
+            catch (error) {
+                threw = true;
+                actualError = error.message;
+            }
+            return this.interpreter.evaluate(node.message, (expectedError) => {
+                const passed = threw &&
+                    (expectedError === undefined ||
+                        actualError?.includes(expectedError));
+                if (this.negated === passed) {
+                    if (!threw) {
+                        throw new FailedAssert(undefined, expectedError, "Expected code to fail, but it succeeded");
+                    }
+                    else {
+                        throw new FailedAssert(actualError, expectedError, `Expected error message to contain "${expectedError}", but got "${actualError}"`);
+                    }
+                }
+                return k(undefined);
+            });
+        };
+    }
+    visitEquality(node) {
+        return (k) => this.interpreter.evaluate(node.value, (value) => {
+            return () => this.interpreter.evaluate(node.expected, (expected) => {
+                this.lazyRuntime.deepEqual(value, expected, (passed) => {
+                    if (this.negated === passed) {
+                        throw new FailedAssert(value, expected, this.negated
+                            ? `Expected ${JSON.stringify(value)} NOT to be equal to ${JSON.stringify(expected)}`
+                            : `Expected ${JSON.stringify(expected)}, but got ${JSON.stringify(value)}`);
+                    }
+                    return k(undefined);
+                });
+            });
+        });
+    }
+    visitTruth(node) {
+        return (k) => this.interpreter.evaluate(node.body, (value) => {
+            const isTruthy = Boolean(value);
+            if (this.negated === isTruthy) {
+                throw new FailedAssert(value, !this.negated, this.negated
+                    ? `Expected value to be falsy, but got ${JSON.stringify(value)}`
+                    : `Expected value to be truthy, but got ${JSON.stringify(value)}`);
+            }
+            return k(undefined);
+        });
+    }
+    fallback(node) {
+        throw new UnexpectedNode(node.constructor.name, "AssertionVisitor");
+    }
+}
+export class TestRunner extends TraverseVisitor {
+    interpreter;
+    lazyRuntime;
+    constructor(interpreter, lazyRuntime) {
+        super();
+        this.interpreter = interpreter;
+        this.lazyRuntime = lazyRuntime;
+    }
+    run(node) {
+        return node.accept(this);
+    }
+    visitTestGroup(node) {
+        return (k) => this.interpreter.evaluate(node.group, () => k(undefined));
+    }
+    visitTest(node) {
+        return (k) => this.interpreter.evaluate(node.body, () => k(undefined));
+    }
+    visitAssert(node) {
+        return (k) => this.interpreter.evaluate(node.negated, (negatedVal) => {
+            const isNegated = Boolean(negatedVal);
+            const visitor = new AssertionVisitor(this.interpreter, isNegated, this.lazyRuntime);
+            return node.body.accept(visitor)(k);
+        });
+    }
+    fallback(node) {
+        throw new UnexpectedNode(node.constructor.name, "TestRunner");
+    }
+}

package/dist/src/interpreter/components/Visitor.d.ts

@@ -0,0 +1,71 @@
+import { Visitor, PrimitiveValue, NumberPrimitive, BooleanPrimitive, StringPrimitive, ListPrimitive, NilPrimitive, SymbolPrimitive, Variable, CharPrimitive, ArithmeticUnaryOperation, ArithmeticBinaryOperation, ListUnaryOperation, ListBinaryOperation, ComparisonOperation, LogicalBinaryOperation, LogicalUnaryOperation, BitwiseBinaryOperation, BitwiseUnaryOperation, StringOperation, UnifyOperation, AssignOperation, Assignment, TupleExpression, FieldExpression, DataExpression, ConsExpression, LetInExpression, Call, Otherwise, CompositionExpression, Expression, Application, Lambda, Sequence, Exist, Not, Findall, Forall, Goal, Send, New, Self, ListComprehension, RangeExpression, Generator as YuGenerator, ASTNode, Raise, Query, TypeCast, Super, If, Assert, Test, TestGroup, LogicConstraint } from "yukigo-ast";
+import { ExpressionEvaluator } from "../utils.js";
+import { ErrorFrame } from "../errors.js";
+import { Continuation, CPSThunk, Thunk } from "../trampoline.js";
+import { RuntimeContext } from "./RuntimeContext.js";
+export declare class InterpreterVisitor implements Visitor<CPSThunk<PrimitiveValue>>, ExpressionEvaluator {
+    private context;
+    private frames;
+    constructor(context: RuntimeContext, frames?: ErrorFrame[]);
+    evaluate<R = PrimitiveValue>(node: ASTNode, cont: Continuation<PrimitiveValue, R>): Thunk<R>;
+    visitSequence(node: Sequence): CPSThunk<PrimitiveValue>;
+    visitAssert(node: Assert): CPSThunk<PrimitiveValue>;
+    visitTest(node: Test): CPSThunk<PrimitiveValue>;
+    visitTestGroup(node: TestGroup): CPSThunk<PrimitiveValue>;
+    visitNumberPrimitive(node: NumberPrimitive): CPSThunk<PrimitiveValue>;
+    visitBooleanPrimitive(node: BooleanPrimitive): CPSThunk<PrimitiveValue>;
+    visitStringPrimitive(node: StringPrimitive): CPSThunk<PrimitiveValue>;
+    visitListPrimitive(node: ListPrimitive): CPSThunk<PrimitiveValue>;
+    visitNilPrimitive(node: NilPrimitive): CPSThunk<PrimitiveValue>;
+    visitCharPrimitive(node: CharPrimitive): CPSThunk<PrimitiveValue>;
+    visitSymbolPrimitive(node: SymbolPrimitive): CPSThunk<PrimitiveValue>;
+    visitVariable(node: Variable): CPSThunk<PrimitiveValue>;
+    visitAssignment(node: Assignment): CPSThunk<PrimitiveValue>;
+    visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): CPSThunk<PrimitiveValue>;
+    visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): CPSThunk<PrimitiveValue>;
+    visitListUnaryOperation(node: ListUnaryOperation): CPSThunk<PrimitiveValue>;
+    visitListBinaryOperation(node: ListBinaryOperation): CPSThunk<PrimitiveValue>;
+    visitComparisonOperation(node: ComparisonOperation): CPSThunk<PrimitiveValue>;
+    visitLogicalBinaryOperation(node: LogicalBinaryOperation): CPSThunk<PrimitiveValue>;
+    visitLogicalUnaryOperation(node: LogicalUnaryOperation): CPSThunk<PrimitiveValue>;
+    visitBitwiseBinaryOperation(node: BitwiseBinaryOperation): CPSThunk<PrimitiveValue>;
+    visitBitwiseUnaryOperation(node: BitwiseUnaryOperation): CPSThunk<PrimitiveValue>;
+    visitStringOperation(node: StringOperation): CPSThunk<PrimitiveValue>;
+    visitUnifyOperation(node: UnifyOperation): CPSThunk<PrimitiveValue>;
+    visitAssignOperation(node: AssignOperation): CPSThunk<PrimitiveValue>;
+    visitTupleExpr(node: TupleExpression): CPSThunk<PrimitiveValue>;
+    visitFieldExpression(node: FieldExpression): CPSThunk<PrimitiveValue>;
+    visitDataExpr(node: DataExpression): CPSThunk<PrimitiveValue>;
+    visitConsExpr(node: ConsExpression): CPSThunk<PrimitiveValue>;
+    visitLetInExpr(node: LetInExpression): CPSThunk<PrimitiveValue>;
+    visitIf(node: If): CPSThunk<PrimitiveValue>;
+    visitCall(node: Call): CPSThunk<PrimitiveValue>;
+    visitOtherwise(node: Otherwise): CPSThunk<PrimitiveValue>;
+    visitCompositionExpression(node: CompositionExpression): CPSThunk<PrimitiveValue>;
+    visitLambda(node: Lambda): CPSThunk<PrimitiveValue>;
+    visitApplication(node: Application): CPSThunk<PrimitiveValue>;
+    visitQuery(node: Query): CPSThunk<PrimitiveValue>;
+    visitExist(node: Exist): CPSThunk<PrimitiveValue>;
+    visitNot(node: Not): CPSThunk<PrimitiveValue>;
+    visitFindall(node: Findall): CPSThunk<PrimitiveValue>;
+    visitForall(node: Forall): CPSThunk<PrimitiveValue>;
+    visitGoal(node: Goal): CPSThunk<PrimitiveValue>;
+    private bindLogicResults;
+    visitLogicConstraint(node: LogicConstraint): CPSThunk<PrimitiveValue>;
+    visitSuper(node: Super): CPSThunk<PrimitiveValue>;
+    visitSend(node: Send): CPSThunk<PrimitiveValue>;
+    visitNew(node: New): CPSThunk<PrimitiveValue>;
+    visitSelf(node: Self): CPSThunk<PrimitiveValue>;
+    visitListComprehension(node: ListComprehension): CPSThunk<PrimitiveValue>;
+    visitTypeCast(node: TypeCast): CPSThunk<PrimitiveValue>;
+    visitGenerator(node: YuGenerator): CPSThunk<PrimitiveValue>;
+    visitRaise(node: Raise): CPSThunk<PrimitiveValue>;
+    visitRangeExpression(node: RangeExpression): CPSThunk<PrimitiveValue>;
+    visit(node: Expression): CPSThunk<PrimitiveValue>;
+    fallback(node: ASTNode): CPSThunk<PrimitiveValue>;
+    realizeList<R = PrimitiveValue[]>(val: PrimitiveValue, k: Continuation<PrimitiveValue[], R>): Thunk<R>;
+    private processBinary;
+    private processUnary;
+    private getLogicEngine;
+    static evaluateLiteral(node: ASTNode): PrimitiveValue;
+}