yukigo 0.2.3 → 0.3.2

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

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

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

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

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

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

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