yukigo 0.1.0 → 0.2.0

package/dist/interpreter/components/Visitor.js

@@ -1,46 +1,119 @@
-import { SymbolPrimitive, VariablePattern, Application, Lambda, UnguardedBody, Sequence, Return, } from "@yukigo/ast";
+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 { define, lookup } from "../utils.js";
-import { LogicEngine } from "./LogicEngine.js";
+import { LogicEngine } from "./logic/LogicEngine.js";
 import { InterpreterError, UnexpectedValue } from "../errors.js";
-import { LazyRuntime } from "./LazyRuntime.js";
-import { FunctionRuntime } from "./FunctionRuntime.js";
+import { EnvBuilderVisitor } from "./EnvBuilder.js";
+import { FailedAssert, TestRunner } from "./TestRunner.js";
+import { idContinuation, trampoline, valueToCPS, } from "../trampoline.js";
+import { RuntimeContext } from "./RuntimeContext.js";
 export class InterpreterVisitor {
+    context;
     frames;
-    env;
-    config;
-    constructor(env, config, frames = []) {
+    constructor(context, frames = []) {
+        this.context = context;
         this.frames = frames;
-        this.env = env;
-        this.config = config;
     }
-    evaluate(node) {
-        return node.accept(this);
+    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 }]);
+            }
+        };
     }
-    getLogicEngine() {
-        return new LogicEngine(this.env, this.config, this);
+    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 node.value;
+        return valueToCPS(node.value);
     }
     visitBooleanPrimitive(node) {
-        return node.value;
+        return valueToCPS(node.value);
     }
     visitStringPrimitive(node) {
-        return node.value;
+        return valueToCPS(node.value);
     }
     visitListPrimitive(node) {
-        return node.elements.map((elem) => elem.accept(this));
+        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 node.value;
+        return valueToCPS(node.value);
     }
     visitCharPrimitive(node) {
-        return node.value;
+        return valueToCPS(node.value);
     }
     visitSymbolPrimitive(node) {
+        if (this.context.config.debug) {
+            console.log(`[Interpreter] Looking for \`${node.value}\` in the environment`);
+        }
         try {
-            return lookup(this.env, node.value);
+            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}\`: ${typeof val === "object" && "type" in val ? val.type : val}`);
+            }
+            return valueToCPS(val);
         }
         catch (error) {
             throw new InterpreterError("Symbol Lookup", error.message, this.frames);
@@ -48,9 +121,34 @@ export class InterpreterVisitor {
     }
     visitVariable(node) {
         const name = node.identifier.value;
-        const value = node.expression.accept(this);
-        this.env.at(-1).set(name, value);
-        return true;
+        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");
@@ -59,42 +157,58 @@ export class InterpreterVisitor {
         return this.processBinary(node, ArithmeticBinaryTable, (a, b) => typeof a === "number" && typeof b === "number", "ArithmeticBinaryOperation");
     }
     visitListUnaryOperation(node) {
-        const operand = node.operand.accept(this);
-        if (!Array.isArray(operand))
-            throw new UnexpectedValue("ListUnaryOperation", "Array", typeof operand);
-        const arr = this.realizeList(operand);
-        const fn = ListUnaryTable[node.operator];
-        if (!fn)
-            throw new InterpreterError("ListUnaryOperation", `Unknown operator: ${node.operator}`);
-        return fn(arr);
+        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) {
-        return this.processBinary(node, ListBinaryTable, (a, b) => Array.isArray(a) && Array.isArray(b), "ListBinaryOperation");
+        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) {
-        const left = node.left.accept(this);
-        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}'`);
-        const rightThunk = () => {
-            const right = node.right.accept(this);
-            if (typeof right !== "boolean")
-                throw new InterpreterError("LogicalBinaryOperation", `Expected right side to be boolean and got: ${right}`);
-            return right;
-        };
-        // short circuit if lazy loading is enabled
-        if (this.config.lazyLoading) {
-            if (node.operator === "And" && left === false)
-                return false;
-            if (node.operator === "Or" && left === true)
-                return true;
-        }
-        return fn(left, rightThunk);
+        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");
@@ -109,56 +223,147 @@ export class InterpreterVisitor {
         return this.processBinary(node, StringOperationTable, (a, b) => typeof a === "string" || typeof b === "string", "StringOperation");
     }
     visitUnifyOperation(node) {
-        throw new Error("Method not implemented.");
+        return (k) => this.getLogicEngine().unifyExpr(node.left, node.right, k);
     }
     visitAssignOperation(node) {
-        throw new Error("Method not implemented.");
+        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) {
-        throw new Error("Method not implemented.");
+        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);
+        };
     }
-    visitFieldExpr(node) {
-        throw new Error("Method not implemented.");
+    visitFieldExpression(node) {
+        return (k) => this.evaluate(node.name, (obj) => {
+            return k(this.context.objRuntime.getField(obj, node.name.value));
+        });
     }
     visitDataExpr(node) {
-        throw new Error("Method not implemented.");
+        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) {
-        try {
-            return LazyRuntime.evaluateCons(node, this, this.config.lazyLoading);
-        }
-        catch (e) {
-            throw new InterpreterError("Cons", e.message, this.frames);
-        }
+        return (k) => this.context.lazyRuntime.evaluateCons(node, this, k);
     }
     visitLetInExpr(node) {
-        throw new Error("Method not implemented.");
+        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) {
-        throw new Error("Method not implemented.");
+        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 true;
+        return valueToCPS(true);
     }
     visitCompositionExpression(node) {
-        const f = node.left.accept(this);
-        const g = node.right.accept(this);
-        if (!this.isRuntimeFunction(f) || !this.isRuntimeFunction(g))
-            throw new InterpreterError("CompositionExpression", "Both operands of (.) must be functions");
-        const fName = `__comp_f_${Date.now()}_${Math.random()
-            .toString(36)
-            .substring(2, 5)}`;
-        const gName = `__comp_g_${Date.now()}_${Math.random()
-            .toString(36)
-            .substring(2, 5)}`;
-        define(this.env, fName, f);
-        define(this.env, gName, g);
-        const arity = g.arity;
-        const placeholders = Array.from({ length: arity }, (_, i) => new VariablePattern(new SymbolPrimitive(`_p${i}`)));
-        const gCall = placeholders.reduce((acc, p) => new Application(acc, new SymbolPrimitive(p.name.value)), new SymbolPrimitive(gName));
-        const composedBody = new Application(new SymbolPrimitive(fName), gCall);
-        const lambda = new Lambda(placeholders, composedBody);
-        return lambda.accept(this);
+        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;
@@ -166,134 +371,264 @@ export class InterpreterVisitor {
             patterns,
             body: new UnguardedBody(new Sequence([new Return(node.body)])),
         };
-        return {
+        return valueToCPS({
+            type: "Function",
             arity: patterns.length,
             equations: [equation],
             pendingArgs: [],
             identifier: "<lambda>",
-            closure: Array.from(this.env),
-        };
+            closure: this.context.env,
+        });
     }
     visitApplication(node) {
-        const func = node.functionExpr.accept(this);
-        if (!this.isRuntimeFunction(func))
-            throw new InterpreterError("Application", "Cannot apply non-function");
-        const argThunk = () => node.parameter.accept(this);
-        const pending = func.pendingArgs
-            ? [...func.pendingArgs, argThunk]
-            : [argThunk];
-        // partially applied
-        if (pending.length < func.arity)
-            return {
-                ...func,
-                pendingArgs: pending,
-            };
-        //  fully applied
-        if (pending.length === func.arity) {
-            const evaluatedArgs = pending.map((arg) => typeof arg === "function" ? arg() : arg);
-            const executionEnv = func.closure ?? this.env;
-            return FunctionRuntime.apply(func.identifier ?? "<anonymous>", func.equations, evaluatedArgs, executionEnv, (newEnv) => new InterpreterVisitor(newEnv, this.config, this.frames));
+        const { funcRuntime } = this.context;
+        if (this.context.config.debug) {
+            console.log(`[Interpreter] Visiting Application`);
         }
-        throw new InterpreterError("Application", "Too many arguments provided");
+        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) {
-        return this.getLogicEngine().solveQuery(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 this.getLogicEngine().solveExist(node);
+        return (k) => this.getLogicEngine().solveExist(node, (res) => {
+            this.bindLogicResults(res);
+            return k(res);
+        });
     }
     visitNot(node) {
-        throw new Error("Method not implemented.");
+        return (k) => this.getLogicEngine().solveNot(node, k);
     }
     visitFindall(node) {
-        return this.getLogicEngine().solveFindall(node);
+        return (k) => this.getLogicEngine().solveFindall(node, k);
     }
     visitForall(node) {
-        throw new Error("Method not implemented.");
+        return (k) => this.getLogicEngine().solveForall(node, k);
     }
     visitGoal(node) {
-        return this.getLogicEngine().solveGoal(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);
+            }
+        }
     }
-    visitSend(node) {
-        throw new Error("Method not implemented.");
+    visitLogicConstraint(node) {
+        return (k) => this.evaluate(node.expression, (val) => {
+            if (Array.isArray(val))
+                return k(val.length > 0);
+            return k(!!val);
+        });
     }
-    visitNew(node) {
-        throw new Error("Method not implemented.");
+    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);
+        };
     }
-    visitImplement(node) {
-        throw new Error("Method not implemented.");
+    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);
+            });
+        };
     }
-    visitInclude(node) {
-        throw new Error("Method not implemented.");
+    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) {
-        throw new Error("Method not implemented.");
+        try {
+            return valueToCPS(this.context.lookup("self"));
+        }
+        catch {
+            throw new InterpreterError("Self", "'self' is not defined in this context");
+        }
     }
     visitListComprehension(node) {
-        throw new Error("Method not implemented.");
+        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) {
-        throw new Error("Method not implemented.");
+        return (k) => this.evaluate(node.expression, k);
     }
     visitRaise(node) {
-        const msg = node.body.accept(this);
-        if (typeof msg !== "string")
-            throw new UnexpectedValue("Raise", "string", typeof msg);
-        throw new InterpreterError("Raise", msg);
+        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) {
-        try {
-            return LazyRuntime.evaluateRange(node, this, this.config);
-        }
-        catch (e) {
-            throw new InterpreterError("Range", e.message, this.frames);
-        }
+        return (k) => this.context.lazyRuntime.evaluateRange(node, this, k);
     }
     visit(node) {
-        return this.safelyVisit(node, () => node.accept(this));
-    }
-    safelyVisit(node, fn) {
-        try {
-            return fn();
-        }
-        catch (err) {
-            if (err instanceof InterpreterError) {
-                err.pushFrame({ nodeType: node.constructor.name, loc: node.loc });
-                throw err;
-            }
-            const wrapped = new InterpreterError(node.constructor.name, err.message, [...this.frames, { nodeType: node.constructor.name, loc: node.loc }]);
-            throw wrapped;
-        }
-    }
-    isRuntimeFunction(val) {
-        return (typeof val === "object" &&
-            val !== null &&
-            Array.isArray(val.equations) &&
-            typeof val.arity === "number");
+        return node.accept(this);
     }
-    realizeList(val) {
-        return LazyRuntime.realizeList(val);
+    realizeList(val, k) {
+        return this.context.lazyRuntime.realizeList(val, k);
     }
     processBinary(node, table, typeGuard, contextName) {
-        const left = node.left.accept(this);
-        const right = node.right.accept(this);
-        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 fn(left, right);
+        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) {
-        const operand = node.operand.accept(this);
-        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 fn(operand);
+        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) {
-        return node.accept(new InterpreterVisitor([new Map()], { lazyLoading: false }));
+        const ctx = new RuntimeContext();
+        const visitor = new InterpreterVisitor(ctx);
+        return trampoline(visitor.evaluate(node, idContinuation));
     }
 }