yukigo 0.2.2 → 0.3.1

package/dist/interpreter/components/logic/LogicTranslator.js

@@ -1,99 +1,236 @@
-import { LiteralPattern, SymbolPrimitive, Variable, VariablePattern, isPattern, NumberPrimitive, StringPrimitive, BooleanPrimitive, ListPrimitive, ListPattern, ConsExpression, ConsPattern, FunctorPattern, } from "yukigo-ast";
-import { instantiate } from "./LogicResolver.js";
+import { isPattern, ConsPattern, } from "yukigo-ast";
+import { VariableTerm, ConstantTerm, ListTerm, ConsTerm, WildcardTerm, CompoundTerm, } from "./LogicTerm.js";
+import { error, raise } from "../../utils.js";
 import { InterpreterError } from "../../errors.js";
-export class LogicTranslator {
+import { StepCommand, BindCommand, } from "../kernel/commands.js";
+import { YuNumber, YuString, YuBoolean, YuNil, isLogicTerm, isRuntimeObject, } from "../../primitives/index.js";
+/**
+ * Sync visitor to convert Patterns to LogicTerms.
+ */
+class PatternToTermVisitor {
+    translator;
+    scope;
+    constructor(translator, scope) {
+        this.translator = translator;
+        this.scope = scope;
+    }
+    visitVariablePattern(node) {
+        const name = node.name.value;
+        if (this.scope) {
+            let term = this.scope.get(name);
+            if (!term) {
+                term = new VariableTerm(this.translator.getNextId(name), name);
+                this.scope.set(name, term);
+            }
+            return term;
+        }
+        return new VariableTerm(this.translator.getNextId(name), name);
+    }
+    visitLiteralPattern(node) {
+        const raw = node.name.value;
+        let wrapped;
+        if (typeof raw === "number")
+            wrapped = new YuNumber(raw);
+        else if (typeof raw === "string")
+            wrapped = new YuString(raw);
+        else if (typeof raw === "boolean")
+            wrapped = new YuBoolean(raw);
+        else
+            wrapped = YuNil.getInstance();
+        return new ConstantTerm(wrapped);
+    }
+    visitListPattern(node) {
+        return new ListTerm(node.elements.map((el) => el.accept(this)));
+    }
+    visitTuplePattern(node) {
+        return new ListTerm(node.elements.map((el) => el.accept(this)));
+    }
+    visitConsPattern(node) {
+        let curr = node;
+        const lefts = [];
+        while (curr instanceof ConsPattern) {
+            lefts.push(curr.left);
+            curr = curr.right;
+        }
+        let result = curr.accept(this);
+        for (let i = lefts.length - 1; i >= 0; i--) {
+            result = new ConsTerm(lefts[i].accept(this), result);
+        }
+        return result;
+    }
+    visitWildcardPattern(node) {
+        return new WildcardTerm();
+    }
+    visitFunctorPattern(node) {
+        return new CompoundTerm(node.identifier.value, node.args.map((a) => a.accept(this)));
+    }
+    visitConstructorPattern(node) {
+        return new CompoundTerm(node.identifier.value, node.args.map((a) => a.accept(this)));
+    }
+    visitAsPattern(node) {
+        return node.right.accept(this);
+    }
+    visitUnionPattern(node) {
+        throw new InterpreterError("Logic", "UnionPattern not supported in logic engine yet");
+    }
+    visitTypePattern(node) {
+        throw new InterpreterError("Logic", "TypePattern not supported in logic engine yet");
+    }
+    visitApplicationPattern(node) {
+        return new CompoundTerm(node.identifier.value, node.args.map((a) => a.accept(this)));
+    }
+    fallback(node) {
+        throw new InterpreterError("Logic", `Pattern ${node.constructor.name} translation not implemented`);
+    }
+}
+/**
+ * Kernel-based visitor to convert Expressions to LogicTerms.
+ */
+class ExpressionToTermVisitor {
+    translator;
     evaluator;
     ctx;
-    constructor(evaluator, ctx) {
+    scope;
+    constructor(translator, evaluator, ctx, scope) {
+        this.translator = translator;
         this.evaluator = evaluator;
         this.ctx = ctx;
+        this.scope = scope;
     }
-    patternToPrimitive(pat) {
-        if (pat instanceof LiteralPattern) {
-            const primitive = pat.name;
-            return primitive.value;
-        }
-        if (pat instanceof ListPattern) {
-            return pat.elements.map((el) => this.patternToPrimitive(el));
+    visitListPrimitive(node) {
+        const terms = [];
+        const next = (index) => {
+            if (index >= node.value.length)
+                return new StepCommand(new ListTerm(terms));
+            return new BindCommand(this.translator.expressionToTerm(node.value[index], this.scope), (t) => {
+                if (!isLogicTerm(t))
+                    return raise(error("ExpressionToTermVisitor", "expected LogicTerm in visitListPrimitive"));
+                terms.push(t);
+                return next(index + 1);
+            });
+        };
+        return next(0);
+    }
+    visitConsExpression(node) {
+        return new BindCommand(this.translator.expressionToTerm(node.head, this.scope), (head) => {
+            if (!isLogicTerm(head))
+                return raise(error("ExpressionToTermVisitor", "expected LogicTerm in visitConsExpression"));
+            return new BindCommand(this.translator.expressionToTerm(node.tail, this.scope), (tail) => {
+                if (!isLogicTerm(tail))
+                    return raise(error("ExpressionToTermVisitor", "expected LogicTerm in visitConsExpression"));
+                return new StepCommand(new ConsTerm(head, tail));
+            });
+        });
+    }
+    visitVariable(node) {
+        const name = node.identifier.value;
+        if (this.ctx.isDefined(name)) {
+            return new BindCommand(this.evaluator.evaluate(node), (val) => {
+                return new StepCommand(this.translator.primitiveToTerm(val));
+            });
         }
-        if (pat instanceof ConsPattern) {
-            const head = this.patternToPrimitive(pat.left);
-            const tail = this.patternToPrimitive(pat.right);
-            if (Array.isArray(tail)) {
-                return [head, ...tail];
+        if (this.scope) {
+            let term = this.scope.get(name);
+            if (!term) {
+                term = new VariableTerm(this.translator.getNextId(name), name);
+                this.scope.set(name, term);
             }
-            return [head, tail];
-        }
-        // Return the pattern itself for non-primitive logic terms (VariablePattern, FunctorPattern, etc.)
-        return pat;
-    }
-    expressionToPattern(expr, k) {
-        if (isPattern(expr))
-            return k(expr);
-        if (expr instanceof ListPrimitive) {
-            const results = [];
-            const next = (index) => {
-                if (index >= expr.value.length)
-                    return k(new ListPattern(results));
-                return this.expressionToPattern(expr.value[index], (p) => {
-                    results.push(p);
-                    return () => next(index + 1);
-                });
-            };
-            return next(0);
+            return new StepCommand(term);
         }
-        if (expr instanceof ConsExpression) {
-            return this.expressionToPattern(expr.head, (headPat) => {
-                return () => this.expressionToPattern(expr.tail, (tailPat) => {
-                    return k(new ConsPattern(headPat, tailPat));
-                });
+        return new StepCommand(new VariableTerm(this.translator.getNextId(name), name));
+    }
+    visitSymbolPrimitive(node) {
+        const name = node.value;
+        if (this.ctx.isDefined(name)) {
+            return new BindCommand(this.evaluator.evaluate(node), (val) => {
+                return new StepCommand(this.translator.primitiveToTerm(val));
             });
         }
-        if (expr instanceof Variable || expr instanceof SymbolPrimitive) {
-            const name = expr instanceof Variable ? expr.identifier.value : expr.value;
-            if (this.ctx.isDefined(name)) {
-                return this.evaluator.evaluate(expr, (val) => {
-                    return k(this.primitiveToPattern(val));
-                });
+        const isVariable = /^[A-Z_]/.test(name);
+        if (!isVariable) {
+            return new StepCommand(new ConstantTerm(new YuString(name)));
+        }
+        if (this.scope) {
+            let term = this.scope.get(name);
+            if (!term) {
+                term = new VariableTerm(this.translator.getNextId(name), name);
+                this.scope.set(name, term);
             }
-            return k(new VariablePattern(expr instanceof Variable ? expr.identifier : expr));
+            return new StepCommand(term);
         }
-        return this.evaluator.evaluate(expr, (val) => {
-            return k(this.primitiveToPattern(val));
-        });
+        return new StepCommand(new VariableTerm(this.translator.getNextId(name), name));
     }
-    primitiveToPattern(val) {
-        if (isPattern(val)) {
-            return val;
-        }
-        if (typeof val === "number") {
-            return new LiteralPattern(new NumberPrimitive(val));
-        }
-        if (typeof val === "string") {
-            return new LiteralPattern(new StringPrimitive(val));
+    fallback(node) {
+        if (isPattern(node)) {
+            return new StepCommand(this.translator.patternToTerm(node, this.scope));
         }
-        if (typeof val === "boolean") {
-            return new LiteralPattern(new BooleanPrimitive(val));
+        return new BindCommand(this.evaluator.evaluate(node), (val) => {
+            return new StepCommand(this.translator.primitiveToTerm(val));
+        });
+    }
+}
+export class LogicTranslator {
+    evaluator;
+    ctx;
+    constructor(evaluator, ctx) {
+        this.evaluator = evaluator;
+        this.ctx = ctx;
+    }
+    getNextId(name) {
+        const id = ++this.ctx.logicState.variableCounter;
+        this.ctx.logicState.idToName.set(id, name);
+        return id;
+    }
+    getName(id) {
+        return this.ctx.logicState.idToName.get(id);
+    }
+    /**
+     * Translates a Pattern (AST) into a LogicTerm (Runtime).
+     */
+    patternToTerm(pat, scope) {
+        const visitor = new PatternToTermVisitor(this, scope);
+        return pat.accept(visitor);
+    }
+    /**
+     * Converts a PrimitiveValue to a LogicTerm.
+     */
+    primitiveToTerm(val) {
+        if (val.asNumeric ||
+            val.asSummable instanceof YuString ||
+            val.asLogic ||
+            val instanceof YuNil) {
+            return new ConstantTerm(val);
         }
-        if (Array.isArray(val)) {
-            return new ListPattern(val.map((v) => this.primitiveToPattern(v)));
+        const seq = val.asSequence;
+        if (seq) {
+            return new ListTerm([...seq].map((v) => this.primitiveToTerm(v)));
         }
-        if (val &&
-            typeof val === "object" &&
-            "type" in val &&
-            val.type === "Object") {
-            // Convert RuntimeObject to FunctorPattern for logic matching
+        if (isRuntimeObject(val)) {
             const args = [];
             for (const [_, fieldVal] of val.fields) {
-                args.push(this.primitiveToPattern(fieldVal));
+                args.push(this.primitiveToTerm(fieldVal));
             }
-            return new FunctorPattern(new SymbolPrimitive(val.className || val.identifier), args);
+            return new CompoundTerm(val.className || val.identifier, args);
         }
-        throw new InterpreterError("primitiveToPattern", `Cannot convert value ${val} to Logic Pattern`);
+        if (isLogicTerm(val))
+            return val;
+        throw new InterpreterError("primitiveToTerm", `Cannot convert value ${val} to Logic Term`);
+    }
+    /**
+     * Evaluates an expression and returns its LogicTerm representation via the Kernel.
+     */
+    expressionToTerm(expr, scope) {
+        const visitor = new ExpressionToTermVisitor(this, this.evaluator, this.ctx, scope);
+        return expr.accept(visitor);
     }
-    instantiateExpressionAsPattern(expr, substs, k) {
-        return this.expressionToPattern(expr, (patternBase) => {
-            return k(instantiate(patternBase, substs));
+    /**
+     * Instantiates an expression as a logic term, resolving logic variables.
+     */
+    instantiateExpressionAsTerm(expr, substs, scope) {
+        return new BindCommand(this.expressionToTerm(expr, scope), (term) => {
+            if (!isLogicTerm(term))
+                return raise(error("instantiateExpressionAsTerm", "expected LogicTerm in visitConsExpression"));
+            return new StepCommand(term.instantiate(substs));
         });
     }
 }

package/dist/interpreter/components/runtimes/FunctionRuntime.d.ts

@@ -1,11 +1,13 @@
-import { PrimitiveValue, RuntimeFunction } from "yukigo-ast";
-import { Continuation, CPSThunk, Thunk } from "../../trampoline.js";
+import { PrimitiveThunk } from "../../utils.js";
 import { RuntimeContext } from "../RuntimeContext.js";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { YuValue } from "../../primitives/YuValue.js";
+import { RuntimeFunction } from "../../primitives/index.js";
 export declare class FunctionRuntime {
     private context;
     constructor(context: RuntimeContext);
-    apply(func: RuntimeFunction, args: PrimitiveValue[], k: Continuation<PrimitiveValue>): Thunk<PrimitiveValue>;
-    applyArguments(func: RuntimeFunction, args: (PrimitiveValue | (() => PrimitiveValue))[]): CPSThunk<PrimitiveValue>;
+    apply(func: RuntimeFunction, args: YuValue[]): ExecutionCommand;
+    applyArguments(func: RuntimeFunction, args?: (YuValue | PrimitiveThunk)[]): ExecutionCommand;
     private preloadDefinitions;
     private patternsMatch;
     private evaluateSequence;

package/dist/interpreter/components/runtimes/FunctionRuntime.js

@@ -1,10 +1,11 @@
-import { UnguardedBody, Sequence, Return, Function, isRuntimeFunction, } from "yukigo-ast";
+import { Return, Function, } from "yukigo-ast";
 import { PatternMatcher } from "../PatternMatcher.js";
+import { boolean, isTrue, raise, error } from "../../utils.js";
 import { InterpreterError } from "../../errors.js";
 import { EnvBuilderVisitor } from "../EnvBuilder.js";
-import { valueToCPS } from "../../trampoline.js";
 import { RuntimeContext } from "../RuntimeContext.js";
-import { InterpreterVisitor } from "../Visitor.js";
+import { StepCommand, BindCommand, FailCommand, RaiseCommand, } from "../kernel/commands.js";
+import { isRuntimeFunction, YuNil, } from "../../primitives/index.js";
 class NonExhaustivePatterns extends InterpreterError {
     constructor(funcName) {
         super("PatternMatch", `Non-exhaustive patterns in '${funcName}'`);
@@ -15,90 +16,88 @@ export class FunctionRuntime {
     constructor(context) {
         this.context = context;
     }
-    apply(func, args, k) {
+    apply(func, args) {
         const funcName = func.identifier;
+        const selfContext = this.context;
         const equations = func.equations;
         const oldEnv = this.context.env;
-        if (this.context.config.debug)
-            console.log(`[FunctionRuntime] Applying function: ${funcName} with args:`, args);
         const tryNextEquation = (eqIndex) => {
             if (eqIndex >= equations.length) {
                 this.context.setEnv(oldEnv);
-                throw new NonExhaustivePatterns(funcName);
+                return raise(new NonExhaustivePatterns(func.name));
             }
             const eq = equations[eqIndex];
             if (eq.patterns.length !== args.length)
-                return () => tryNextEquation(eqIndex + 1);
+                return tryNextEquation(eqIndex + 1);
             const bindings = [];
-            return this.patternsMatch(eq, args, bindings, (isMatch) => {
-                if (!isMatch)
-                    return () => tryNextEquation(eqIndex + 1);
-                if (this.context.config.debug)
-                    console.log(`[FunctionRuntime] Match successful for ${funcName} equation ${eqIndex}`);
+            return new BindCommand(this.patternsMatch(eq, args, bindings), (matchRes) => {
+                if (!isTrue(matchRes))
+                    return tryNextEquation(eqIndex + 1);
                 const localEnv = new Map(bindings);
                 if (func.closure)
-                    this.context.setEnv(func.closure);
+                    this.context.setEnv(this.context.cloneEnv(func.closure));
                 this.context.pushEnv(localEnv);
-                const wrappedK = (res) => {
+                const nextWithEnvRestore = (res) => {
                     this.context.setEnv(oldEnv);
-                    return k(res);
+                    return new StepCommand(res);
                 };
-                const evaluatorFactory = (ctx) => new InterpreterVisitor(ctx);
-                const body = eq.body;
-                // UnguardedBody
-                if (body instanceof UnguardedBody)
-                    return this.evaluateSequence(body.sequence, this.context, evaluatorFactory, wrappedK);
-                // GuardedBody
-                return () => {
-                    if (Array.isArray(body) && body.length > 0) {
-                        const prototypeBody = body[0].body;
-                        if (prototypeBody instanceof Sequence)
-                            this.preloadDefinitions(prototypeBody, evaluatorFactory);
+                const dummyVisitor = this.context.evaluatorFactory(this.context);
+                const BaseVisitor = dummyVisitor.constructor;
+                class GuardBacktrackingVisitor extends BaseVisitor {
+                    visitGuardedExpression(expr) {
+                        const tryNextGuard = (guardIndex) => {
+                            if (guardIndex >= expr.guards.length) {
+                                selfContext.setEnv(oldEnv);
+                                return tryNextEquation(eqIndex + 1);
+                            }
+                            const guard = expr.guards[guardIndex];
+                            return new BindCommand(this.evaluate(guard.condition), (cond) => {
+                                if (!isTrue(cond))
+                                    return tryNextGuard(guardIndex + 1);
+                                return this.evaluate(guard.body);
+                            });
+                        };
+                        return tryNextGuard(0);
                     }
-                    const tryNextGuard = (guardIndex) => {
-                        if (guardIndex >= body.length) {
-                            this.context.setEnv(oldEnv);
-                            return () => tryNextEquation(eqIndex + 1);
+                }
+                const evaluatorFactory = (ctx) => new GuardBacktrackingVisitor(ctx);
+                return eq.body.accept({
+                    visitUnguardedBody: (b) => {
+                        return new BindCommand(this.evaluateSequence(b.sequence, this.context, evaluatorFactory), nextWithEnvRestore);
+                    },
+                    visitNativeBody: (b) => {
+                        const currentHolder = this.context.lookup("__CONTEXT_CLASS__");
+                        const lookupKey = `${currentHolder.identifier}.${funcName}`;
+                        const nativeImpl = this.context.config.nativeProviders.get(lookupKey);
+                        if (nativeImpl) {
+                            const capturedContext = this.context.clone();
+                            return new BindCommand(nativeImpl(this.context.lookup("self"), args, capturedContext), nextWithEnvRestore);
                         }
-                        const evaluator = evaluatorFactory(this.context);
-                        const guard = body[guardIndex];
-                        return evaluator.evaluate(guard.condition, (cond) => {
-                            if (cond !== true)
-                                return () => tryNextGuard(guardIndex + 1);
-                            if (!(guard.body instanceof Sequence))
-                                return evaluator.evaluate(guard.body, wrappedK);
-                            return this.evaluateSequence(guard.body, this.context, evaluatorFactory, wrappedK);
-                        });
-                    };
-                    return tryNextGuard(0);
-                };
+                        const voidObj = this.context.lookup("void");
+                        return nextWithEnvRestore(voidObj ?? YuNil.getInstance());
+                    },
+                    fallback: (node) => {
+                        return new RaiseCommand(new InterpreterError("FunctionRuntime.apply", `Unexpected node: ${node.toJSON()}`));
+                    },
+                });
             });
         };
         return tryNextEquation(0);
     }
     applyArguments(func, args) {
-        if (args.length < func.arity) {
-            return valueToCPS({
-                ...func,
-                pendingArgs: args,
-            });
-        }
-        const argsToConsume = args.slice(0, func.arity);
-        const remainingArgs = args.slice(func.arity);
+        const targetFunc = args ? func.bind(...args) : func;
+        const allArgs = targetFunc.pendingArgs ?? [];
+        if (allArgs.length < targetFunc.arity)
+            return new StepCommand(targetFunc);
+        const argsToConsume = allArgs.slice(0, targetFunc.arity);
+        const remainingArgs = allArgs.slice(targetFunc.arity);
         const evaluatedArgs = argsToConsume.map((arg) => typeof arg === "function" ? arg() : arg);
-        return (cont) => () => this.apply(func, evaluatedArgs, (result) => {
-            if (remainingArgs.length > 0) {
-                if (isRuntimeFunction(result)) {
-                    const nextArgs = result.pendingArgs
-                        ? [...result.pendingArgs, ...remainingArgs]
-                        : remainingArgs;
-                    return this.applyArguments(result, nextArgs)(cont);
-                }
-                else {
-                    throw new InterpreterError("Application", `Too many arguments provided. Result was '${result}' (not a function), but had ${remainingArgs.length} args left.`);
-                }
-            }
-            return cont(result);
+        return new BindCommand(this.apply(targetFunc, evaluatedArgs), (result) => {
+            if (remainingArgs.length == 0)
+                return new StepCommand(result);
+            if (!isRuntimeFunction(result))
+                return new FailCommand(new Error(`[Application] Too many arguments provided. Result was '${result}' (not a function), but had ${remainingArgs.length} args left.`));
+            return this.applyArguments(result, remainingArgs);
         });
     }
     preloadDefinitions(seq, evaluatorFactory) {
@@ -106,42 +105,41 @@ export class FunctionRuntime {
         new EnvBuilderVisitor(ctx).build(seq.statements);
         const evaluator = evaluatorFactory(ctx);
         for (const stmt of seq.statements) {
-            if (stmt instanceof Function || stmt instanceof Return)
+            if (stmt.is(Function) || stmt.is(Return))
                 continue;
-            evaluator.evaluate(stmt, (val) => val);
+            evaluator.evaluate(stmt);
         }
     }
-    patternsMatch(eq, args, bindings, k) {
+    patternsMatch(eq, args, bindings) {
         const matchNext = (index) => {
             if (index >= args.length)
-                return k(true);
+                return boolean(true);
             const matcher = new PatternMatcher(args[index], bindings, this.context);
-            return eq.patterns[index].accept(matcher)((isMatch) => {
-                if (!isMatch)
-                    return k(false);
-                return () => matchNext(index + 1);
+            return new BindCommand(eq.patterns[index].accept(matcher), (res) => {
+                if (!isTrue(res))
+                    return boolean(false);
+                return matchNext(index + 1);
             });
         };
         return matchNext(0);
     }
-    evaluateSequence(seq, ctx, evaluatorFactory, k) {
+    evaluateSequence(seq, ctx, evaluatorFactory) {
         new EnvBuilderVisitor(ctx).build(seq.statements);
         const evaluator = evaluatorFactory(ctx);
         const evaluateNext = (index, lastResult) => {
             if (index >= seq.statements.length)
-                return k(lastResult);
+                return new StepCommand(lastResult);
             const stmt = seq.statements[index];
-            if (stmt instanceof Function)
-                return () => evaluateNext(index + 1, lastResult);
-            if (stmt instanceof Return) {
-                return evaluator.evaluate(stmt.body, k);
-            }
-            else {
-                return evaluator.evaluate(stmt, (result) => {
-                    return () => evaluateNext(index + 1, result);
+            if (stmt.is(Function))
+                return evaluateNext(index + 1, lastResult);
+            if (!stmt.is(Return))
+                return new BindCommand(evaluator.evaluate(stmt), (result) => {
+                    return evaluateNext(index + 1, result);
                 });
-            }
+            if (!stmt.body)
+                return raise(error("FunctionRuntime", "Return \`body\` was undefined"));
+            return evaluator.evaluate(stmt.body);
         };
-        return evaluateNext(0, undefined);
+        return evaluateNext(0, YuNil.getInstance());
     }
 }

package/dist/interpreter/components/runtimes/LazyRuntime.d.ts

@@ -1,19 +1,18 @@
-import { PrimitiveValue, RangeExpression, ConsExpression, ListBinaryOperation } from "yukigo-ast";
-import { ExpressionEvaluator } from "../../utils.js";
-import { Continuation, Thunk } from "../../trampoline.js";
+import { RangeExpression, ConsExpression } from "yukigo-ast";
 import { RuntimeContext } from "../RuntimeContext.js";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { YuValue } from "../../primitives/YuValue.js";
+import { YuSequence } from "../../primitives/capabilities.js";
+import { Evaluator } from "../evaluators/BaseEvaluator.js";
 export declare class LazyRuntime {
     private context;
     constructor(context: RuntimeContext);
-    realizeList<R = PrimitiveValue[]>(val: PrimitiveValue, k: Continuation<PrimitiveValue[], R>): Thunk<R>;
-    evaluateRange(node: RangeExpression, evaluator: ExpressionEvaluator, k: Continuation<PrimitiveValue>): Thunk<PrimitiveValue>;
-    evaluateCons(node: ConsExpression, evaluator: ExpressionEvaluator, k: Continuation<PrimitiveValue>): Thunk<PrimitiveValue>;
-    evaluateConcat(left: PrimitiveValue, right: PrimitiveValue, k: Continuation<PrimitiveValue>): Thunk<PrimitiveValue>;
-    evaluateConcatLazy(node: ListBinaryOperation, evaluator: ExpressionEvaluator, k: Continuation<PrimitiveValue>): Thunk<PrimitiveValue>;
-    deepEqual<R = boolean>(a: PrimitiveValue, b: PrimitiveValue, k: Continuation<boolean, R>): Thunk<R>;
-    private isPlainObject;
-    private isCollection;
-    private isListLike;
-    private deepEqualCollection;
-    private deepEqualObject;
+    /**
+     * Realizes a list or lazy list into a YuArray.
+     */
+    realizeList(val: YuValue): ExecutionCommand;
+    evaluateRange(node: RangeExpression, evaluator: Evaluator): ExecutionCommand;
+    evaluateCons(node: ConsExpression, evaluator: Evaluator): ExecutionCommand;
+    private arrayToLazyList;
+    evaluateConcat(left: YuSequence, right: YuSequence): ExecutionCommand;
 }