yukigo 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 0.2.0 (2026-04-11)
+
+### 🚀 Features
+
+- **yukigo:** agrego `clone` a `RuntimeContext` para clonar el entorno ([ee8e0af](https://github.com/miyukiproject/yukigo/commit/ee8e0af))
+
+### 🩹 Fixes
+
+- **yukigo:** permitir a las inspections tener args undefined ([4f36ebe](https://github.com/miyukiproject/yukigo/commit/4f36ebe))
+- **yukigo:** Evaluar `Equal` y `NotEqual` fuera de `processBinary` ([31eca15](https://github.com/miyukiproject/yukigo/commit/31eca15))
+- **yukigo:** delegue logica de deepEqual a LazyRuntime ([8496113](https://github.com/miyukiproject/yukigo/commit/8496113))
+- **yukigo:** evaluateConcatLazy permite eager y lazy evaluation ([3faf646](https://github.com/miyukiproject/yukigo/commit/3faf646))
+- **yukigo:** corrijo `isEqual` para que compare strings con listas ([d6225c9](https://github.com/miyukiproject/yukigo/commit/d6225c9))
+- **yukigo:** corrijo manejo de entorno en `applyArguments` y `visitApplication` ([5c7ab1f](https://github.com/miyukiproject/yukigo/commit/5c7ab1f))
+- **yukigo:** capturar correctamente el entorno en `evaluateCons` ([a1bc7a4](https://github.com/miyukiproject/yukigo/commit/a1bc7a4))
+- **yukigo:** `popEnv` no tiene que esperar el `env` por parametro ([575bacf](https://github.com/miyukiproject/yukigo/commit/575bacf))
+- **yukigo:** agrego metodo visitTypeCast faltante ([61c9984](https://github.com/miyukiproject/yukigo/commit/61c9984))
+
+### 🧱 Updated Dependencies
+
+- Updated yukigo-ast to 0.2.0
+
+### ❤️ Thank You
+
+- noiseArch
+
 ## 0.1.0 (2025-12-09)
 
 ### 🧱 Updated Dependencies

package/dist/analyzer/index.d.ts

@@ -9,7 +9,7 @@ export type AnalysisResult = {
 export type InspectionRule = {
     inspection: string;
     binding?: string;
-    args: string[];
+    args?: string[];
     expected: boolean;
 };
 export declare const DefaultInspectionSet: InspectionMap;

package/dist/analyzer/index.js

@@ -121,7 +121,8 @@ export class Analyzer {
             // Execution Loop
             const isGlobalVisitor = !rule.binding || rule.binding === "*";
             const normalizedBinding = isGlobalVisitor ? undefined : rule.binding;
-            const visitor = new InspectionClass(...rule.args, normalizedBinding);
+            const args = rule.args ?? [];
+            const visitor = new InspectionClass(...args, normalizedBinding);
             for (const { node, binding } of targets) {
                 try {
                     if (!isGlobalVisitor && visitor.setBinding) {

package/dist/interpreter/components/PatternMatcher.d.ts

@@ -1,4 +1,4 @@
-import { ApplicationPattern, AsPattern, ASTNode, ConsPattern, ConstructorPattern, Expression, FunctorPattern, LazyList, ListPattern, LiteralPattern, PrimitiveValue, TuplePattern, UnionPattern, VariablePattern, Visitor, WildcardPattern, TypePattern } from "yukigo-ast";
+import { ApplicationPattern, AsPattern, ASTNode, ConsPattern, ConstructorPattern, Expression, FunctorPattern, LazyList, ListPattern, LiteralPattern, PrimitiveValue, TuplePattern, UnionPattern, VariablePattern, Visitor, WildcardPattern, TypePattern, EnvStack } from "yukigo-ast";
 import { Bindings } from "../index.js";
 import { CPSThunk } from "../trampoline.js";
 import { RuntimeContext } from "./RuntimeContext.js";
@@ -17,6 +17,7 @@ export interface InternalConsState {
     readonly head: PrimitiveValue;
     readonly tailExpr: Expression;
     readonly evaluator: ExpressionEvaluator;
+    readonly capturedEnv: EnvStack;
     realizedTail?: PrimitiveValue;
 }
 export interface MemoizedLazyList extends LazyList {

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

@@ -27,8 +27,9 @@ export declare class RuntimeContext {
     isDefined(name: string): boolean;
     pushEnv(frame?: Environment): void;
     replace(name: string, value: PrimitiveValue, onReplace?: (env: Environment) => void): boolean;
-    popEnv(env: EnvStack): void;
+    popEnv(): void;
     lookup(name: string): PrimitiveValue;
     remove(name: string): void;
     define(name: string, value: PrimitiveValue): void;
+    clone(env?: EnvStack): EnvStack;
 }

package/dist/interpreter/components/RuntimeContext.js

@@ -63,10 +63,10 @@ export class RuntimeContext {
         }
         return false;
     }
-    popEnv(env) {
-        if (!env.tail)
+    popEnv() {
+        if (!this.env.tail)
             throw new Error("Runtime Error: Cannot pop the global environment scope.");
-        this.env = env.tail;
+        this.env = this.env.tail;
     }
     lookup(name) {
         let current = this.env;
@@ -83,4 +83,11 @@ export class RuntimeContext {
     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/interpreter/components/TestRunner.js

@@ -53,7 +53,7 @@ class AssertionVisitor extends TraverseVisitor {
     visitEquality(node) {
         return (k) => this.interpreter.evaluate(node.value, (value) => {
             return () => this.interpreter.evaluate(node.expected, (expected) => {
-                return this.isEqual(value, expected, (passed) => {
+                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)}`
@@ -75,47 +75,6 @@ class AssertionVisitor extends TraverseVisitor {
             return k(undefined);
         });
     }
-    isEqual(a, b, k) {
-        if (a === b)
-            return k(true);
-        if (a && b && typeof a === "object" && typeof b === "object") {
-            return this.lazyRuntime.realizeList(a, (valA) => {
-                return () => this.lazyRuntime.realizeList(b, (valB) => {
-                    if (Array.isArray(valA) && Array.isArray(valB)) {
-                        if (valA.length !== valB.length)
-                            return k(false);
-                        const checkNext = (index) => {
-                            if (index >= valA.length)
-                                return k(true);
-                            return this.isEqual(valA[index], valB[index], (res) => {
-                                if (!res)
-                                    return k(false);
-                                return () => checkNext(index + 1);
-                            });
-                        };
-                        return checkNext(0);
-                    }
-                    if (Array.isArray(valA) !== Array.isArray(valB))
-                        return k(false);
-                    const keys = Object.keys(valA);
-                    if (keys.length !== Object.keys(valB).length)
-                        return k(false);
-                    const checkNextKey = (index) => {
-                        if (index >= keys.length)
-                            return k(true);
-                        const key = keys[index];
-                        return this.isEqual(valA[key], valB[key], (res) => {
-                            if (!res)
-                                return k(false);
-                            return () => checkNextKey(index + 1);
-                        });
-                    };
-                    return checkNextKey(0);
-                });
-            });
-        }
-        return k(false);
-    }
 }
 export class TestRunner extends TraverseVisitor {
     interpreter;

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

@@ -1,4 +1,4 @@
-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, Super, If, Assert, Test, TestGroup, LogicConstraint } from "yukigo-ast";
+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";
@@ -44,7 +44,6 @@ export declare class InterpreterVisitor implements Visitor<CPSThunk<PrimitiveVal
     visitCompositionExpression(node: CompositionExpression): CPSThunk<PrimitiveValue>;
     visitLambda(node: Lambda): CPSThunk<PrimitiveValue>;
     visitApplication(node: Application): CPSThunk<PrimitiveValue>;
-    private applyArguments;
     visitQuery(node: Query): CPSThunk<PrimitiveValue>;
     visitExist(node: Exist): CPSThunk<PrimitiveValue>;
     visitNot(node: Not): CPSThunk<PrimitiveValue>;
@@ -58,6 +57,7 @@ export declare class InterpreterVisitor implements Visitor<CPSThunk<PrimitiveVal
     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>;

package/dist/interpreter/components/Visitor.js

@@ -185,6 +185,9 @@ export class InterpreterVisitor {
             (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) {
@@ -378,46 +381,28 @@ export class InterpreterVisitor {
         });
     }
     visitApplication(node) {
+        const { funcRuntime } = this.context;
         if (this.context.config.debug) {
             console.log(`[Interpreter] Visiting Application`);
         }
         return (k) => this.evaluate(node.functionExpr, (func) => {
             if (!isRuntimeFunction(func))
                 throw new InterpreterError("Application", "Cannot apply non-function");
-            return this.evaluate(node.parameter, (arg) => {
+            const applyFuncToNode = (func) => (k) => this.evaluate(node.parameter, (arg) => {
                 const argThunk = () => arg;
                 const allPendingArgs = func.pendingArgs
                     ? [...func.pendingArgs, argThunk]
                     : [argThunk];
-                return this.applyArguments(func, allPendingArgs)(k);
+                return funcRuntime.applyArguments(func, allPendingArgs)(k);
             });
-        });
-    }
-    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 evaluatedArgs = argsToConsume.map((arg) => typeof arg === "function" ? arg() : arg);
-        if (func.closure)
-            this.context.pushEnv(func.closure.head);
-        return (cont) => () => this.context.funcRuntime.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.`);
-                }
+            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 cont(result);
+            return applyFuncToNode(func)(k);
         });
     }
     visitQuery(node) {
@@ -594,6 +579,9 @@ export class InterpreterVisitor {
             return process(0);
         };
     }
+    visitTypeCast(node) {
+        return node.expression.accept(this);
+    }
     visitGenerator(node) {
         return (k) => this.evaluate(node.expression, k);
     }

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

@@ -1,10 +1,11 @@
 import { PrimitiveValue, RuntimeFunction } from "yukigo-ast";
-import { Continuation, Thunk } from "../../trampoline.js";
+import { Continuation, CPSThunk, Thunk } from "../../trampoline.js";
 import { RuntimeContext } from "../RuntimeContext.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>;
     private preloadDefinitions;
     private patternsMatch;
     private evaluateSequence;

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

@@ -1,7 +1,8 @@
-import { UnguardedBody, Sequence, Return, Function, } from "yukigo-ast";
+import { UnguardedBody, Sequence, Return, Function, isRuntimeFunction, } from "yukigo-ast";
 import { PatternMatcher } from "../PatternMatcher.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";
 class NonExhaustivePatterns extends InterpreterError {
@@ -17,10 +18,12 @@ export class FunctionRuntime {
     apply(func, args, k) {
         const funcName = func.identifier;
         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);
             }
             const eq = equations[eqIndex];
@@ -33,7 +36,6 @@ export class FunctionRuntime {
                 if (this.context.config.debug)
                     console.log(`[FunctionRuntime] Match successful for ${funcName} equation ${eqIndex}`);
                 const localEnv = new Map(bindings);
-                const oldEnv = this.context.env;
                 if (func.closure)
                     this.context.setEnv(func.closure);
                 this.context.pushEnv(localEnv);
@@ -74,6 +76,31 @@ export class FunctionRuntime {
         };
         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 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);
+        });
+    }
     preloadDefinitions(seq, evaluatorFactory) {
         const ctx = new RuntimeContext();
         new EnvBuilderVisitor(ctx).build(seq.statements);

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

@@ -11,4 +11,9 @@ export declare class LazyRuntime {
     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;
 }

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

@@ -78,14 +78,15 @@ export class LazyRuntime {
         });
     }
     evaluateCons(node, evaluator, k) {
-        const capturedEnv = this.context.env;
         const ctx = this.context;
+        const capturedEnv = ctx.clone();
         return evaluator.evaluate(node.head, (head) => {
-            if (this.context.config.lazyLoading) {
+            if (ctx.config.lazyLoading) {
                 const consState = {
                     head,
                     tailExpr: node.tail,
                     evaluator,
+                    capturedEnv,
                     realizedTail: undefined,
                 };
                 const consList = {
@@ -97,7 +98,7 @@ export class LazyRuntime {
                                 yield current.head;
                                 if (current.realizedTail === undefined) {
                                     const prevEnv = ctx.env;
-                                    ctx.setEnv(capturedEnv);
+                                    ctx.setEnv(current.capturedEnv);
                                     try {
                                         current.realizedTail = trampoline(current.evaluator.evaluate(current.tailExpr, idContinuation));
                                     }
@@ -178,61 +179,91 @@ export class LazyRuntime {
         });
     }
     evaluateConcatLazy(node, evaluator, k) {
-        const capturedEnv = this.context.env;
         const ctx = this.context;
-        return k(createMemoizedStream(function* () {
-            const prevEnv = ctx.env;
-            ctx.setEnv(capturedEnv);
-            try {
-                const left = trampoline(evaluator.evaluate(node.left, idContinuation));
+        return evaluator.evaluate(node.left, (left) => {
+            const capturedEnv = ctx.clone();
+            return k(createMemoizedStream(function* () {
                 if (Array.isArray(left))
                     yield* left;
                 else if (typeof left === "string")
                     yield* left.split("");
                 else if (isLazyList(left))
                     yield* left.generator();
-                const right = trampoline(evaluator.evaluate(node.right, idContinuation));
+                else
+                    throw new Error("Invalid left operand for lazy Concat");
+                // right evaluates lazily on demand
+                const prevEnv = ctx.env;
+                ctx.setEnv(capturedEnv);
+                let right;
+                try {
+                    right = trampoline(evaluator.evaluate(node.right, idContinuation));
+                }
+                finally {
+                    ctx.setEnv(prevEnv);
+                }
                 if (Array.isArray(right))
                     yield* right;
                 else if (typeof right === "string")
                     yield* right.split("");
                 else if (isLazyList(right))
                     yield* right.generator();
-            }
-            finally {
-                ctx.setEnv(prevEnv);
-            }
-        }));
+                else
+                    throw new Error("Invalid right operand for lazy Concat");
+            }));
+        });
     }
     deepEqual(a, b, k) {
         if (a === b)
             return k(true);
-        const compareValues = (valA, valB) => {
-            if (typeof valA === "string" && typeof valB === "string")
-                return k(valA === valB);
-            if (Array.isArray(valA) && Array.isArray(valB)) {
+        const aIsListLike = this.isListLike(a);
+        const bIsListLike = this.isListLike(b);
+        const eitherIsCollection = this.isCollection(a) || this.isCollection(b);
+        if (eitherIsCollection && aIsListLike && bIsListLike) {
+            return this.realizeList(a, (valA) => () => this.realizeList(b, (valB) => {
                 if (valA.length !== valB.length)
                     return k(false);
-                const compareNext = (index) => {
-                    if (index >= valA.length)
-                        return k(true);
-                    return () => this.deepEqual(valA[index], valB[index], (isEqual) => {
-                        if (!isEqual)
-                            return k(false);
-                        return () => compareNext(index + 1);
-                    });
-                };
-                return compareNext(0);
-            }
-            return k(valA == valB);
-        };
-        if (isLazyList(a) || isLazyList(b)) {
-            return this.realizeList(a, (valA) => {
-                return () => this.realizeList(b, (valB) => {
-                    return () => compareValues(valA, valB);
-                });
-            });
+                return this.deepEqualCollection(valA, valB, 0, k);
+            }));
         }
-        return compareValues(a, b);
+        if (eitherIsCollection)
+            return k(false); // colección vs número → false
+        if (this.isPlainObject(a) && this.isPlainObject(b))
+            return this.deepEqualObject(a, b, k);
+        return k(a == b); // primitivos: number, boolean, string==number
+    }
+    isPlainObject(val) {
+        return val !== null && typeof val === "object"
+            && !isLazyList(val) && !Array.isArray(val);
+    }
+    isCollection(val) {
+        return Array.isArray(val) || isLazyList(val);
+    }
+    isListLike(val) {
+        return Array.isArray(val) || isLazyList(val) || typeof val === "string";
+    }
+    deepEqualCollection(a, b, index, k) {
+        if (index >= a.length)
+            return k(true);
+        return this.deepEqual(a[index], b[index], (eq) => {
+            if (!eq)
+                return k(false);
+            return () => this.deepEqualCollection(a, b, index + 1, k);
+        });
+    }
+    deepEqualObject(a, b, k) {
+        const keys = Object.keys(a);
+        if (keys.length !== Object.keys(b).length)
+            return k(false);
+        const checkNext = (index) => {
+            if (index >= keys.length)
+                return k(true);
+            const key = keys[index];
+            return this.deepEqual(a[key], b[key], (eq) => {
+                if (!eq)
+                    return k(false);
+                return () => checkNext(index + 1);
+            });
+        };
+        return checkNext(0);
     }
 }

package/dist/interpreter/entities.d.ts

@@ -0,0 +1,105 @@
+import { Fact, Rule, Pattern, GuardedBody, UnguardedBody } from "yukigo-ast";
+export type SuccessLogicResult = {
+    success: true;
+    solutions: Map<string, PrimitiveValue>;
+};
+export type FailedLogicResult = {
+    success: false;
+};
+export type LogicResult = SuccessLogicResult | FailedLogicResult;
+export type PrimitiveValue = number | boolean | string | RuntimeFunction | RuntimePredicate | LogicResult | LazyList | null | void | PrimitiveValue[] | RuntimeObject | RuntimeClass | undefined;
+export declare function isLogicResult(value: PrimitiveValue): value is LogicResult;
+export type PrimitiveThunk = () => PrimitiveValue;
+export type Environment = Map<string, PrimitiveValue>;
+export type EnvStack = {
+    head: Environment;
+    tail: EnvStack | null;
+};
+type RuntimePredicateKind = "Fact" | "Rule" | "Predicate";
+type PredicateEquation = Fact | Rule;
+export interface IRuntimePredicate {
+    kind: RuntimePredicateKind;
+    identifier: string;
+    equations: PredicateEquation[];
+}
+export declare class RuntimePredicate implements IRuntimePredicate {
+    kind: RuntimePredicateKind;
+    identifier: string;
+    equations: PredicateEquation[];
+    constructor(kind: RuntimePredicateKind, identifier: string, equations: PredicateEquation[]);
+    pushEquation<T extends Fact | Rule>(eq: T): void;
+}
+export declare const isRuntimePredicate: (prim: PrimitiveValue) => prim is RuntimePredicate;
+type Body = GuardedBody[] | UnguardedBody;
+export interface IRuntimeEquation {
+    patterns: Pattern[];
+    body: Body;
+}
+export declare class RuntimeEquation implements IRuntimeEquation {
+    patterns: Pattern[];
+    body: Body;
+    constructor(patterns: Pattern[], body: Body);
+}
+type PendingArg = PrimitiveValue | PrimitiveThunk;
+/**
+ * Runtime Function used in the Interpreter
+ */
+export interface IRuntimeFunction {
+    arity: number;
+    identifier: string;
+    equations: RuntimeEquation[];
+    pendingArgs: PendingArg[];
+    closure?: EnvStack;
+}
+export declare class RuntimeFunction implements IRuntimeFunction {
+    arity: number;
+    identifier: string;
+    equations: RuntimeEquation[];
+    pendingArgs: PendingArg[];
+    closure?: EnvStack;
+    constructor(arity: number, identifier: string, equations: RuntimeEquation[], pendingArgs: PendingArg[], closure?: EnvStack);
+    setPendingArgs(args: PendingArg[]): void;
+}
+export declare function isRuntimeFunction(val: PrimitiveValue): val is RuntimeFunction;
+type Fields = Map<string, PrimitiveValue>;
+type Methods = Map<string, RuntimeFunction>;
+export interface IRuntimeClass {
+    identifier: string;
+    fields: Fields;
+    methods: Methods;
+    mixins: string[];
+    superclass?: string;
+}
+export declare class RuntimeClass implements IRuntimeClass {
+    identifier: string;
+    fields: Fields;
+    methods: Methods;
+    mixins: string[];
+    superclass?: string;
+    constructor(identifier: string, fields: Fields, methods: Methods, mixins: string[], superclass?: string);
+}
+export declare function isRuntimeClass(val: PrimitiveValue): val is RuntimeClass;
+export interface IRuntimeObject {
+    identifier: string;
+    className: string;
+    fields: Map<string, PrimitiveValue>;
+    methods: Map<string, RuntimeFunction>;
+}
+export declare class RuntimeObject implements IRuntimeObject {
+    identifier: string;
+    className: string;
+    fields: Fields;
+    methods: Methods;
+    constructor(identifier: string, className: string, fields: Fields, methods: Methods);
+}
+export declare function isRuntimeObject(val: PrimitiveValue): val is RuntimeObject;
+export type LazyGenerator = () => Generator<PrimitiveValue, void, unknown>;
+export interface ILazyList {
+    readonly generator: LazyGenerator;
+}
+export declare class LazyList implements ILazyList {
+    readonly generator: LazyGenerator;
+    constructor(generator: LazyGenerator);
+}
+export declare function isLazyList(prim: unknown): prim is LazyList;
+export {};