yukigo 0.2.3 → 0.3.2

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

@@ -1,471 +1,104 @@
-import { Fact, FunctorPattern, ListPattern, LiteralPattern, Rule, VariablePattern, WildcardPattern, isRuntimePredicate, UnguardedBody, Findall, ConsPattern, Equation, SymbolPrimitive, Goal, Exist, LogicConstraint, Sequence, Not, ComparisonOperation, UnifyOperation, ApplicationPattern, TuplePattern, ConstructorPattern, UnionPattern, AsPattern, TypePattern, AssignOperation, ArithmeticBinaryOperation, ArithmeticUnaryOperation, ConsExpression, ListPrimitive, TupleExpression, If, Forall, Call, ListBinaryOperation, ListUnaryOperation, LogicalBinaryOperation, LogicalUnaryOperation, BitwiseBinaryOperation, BitwiseUnaryOperation, StringOperation, isUnguardedBody, } from "yukigo-ast";
+import { InterpreterError } from "../../errors.js";
+import { StepCommand, BindCommand, FailCommand, ChoiceCommand, BacktrackCommand, } from "../kernel/commands.js";
+import { isLogicResult, LogicResult, LogicAnswer, isRuntimePredicate, YuBoolean, YuNil, } from "../../primitives/index.js";
 /**
- * Creates a successful logic result.
+ * Unified parameter list unification.
  */
-export function success(substs) {
-    return { success: true, substs };
-}
-/**
- * Unifies two patterns given an existing set of substitutions.
- * Returns the updated substitution map or null if unification fails.
- */
-export function unify(t1, t2, argEnv) {
-    const env = argEnv ? new Map(argEnv) : new Map();
-    return unifyInPlace(t1, t2, env) ? env : null;
-}
-/**
- * Internal unification that modifies the environment in place for efficiency during recursion.
- */
-function unifyInPlace(t1, t2, env) {
-    const r1 = resolve(t1, env);
-    const r2 = resolve(t2, env);
-    if (r1 === r2)
-        return true;
-    if (r1 instanceof WildcardPattern || r2 instanceof WildcardPattern) {
-        return true;
-    }
-    if (r1 instanceof VariablePattern) {
-        env.set(r1.name.value, r2);
-        return true;
-    }
-    if (r2 instanceof VariablePattern) {
-        env.set(r2.name.value, r1);
-        return true;
-    }
-    if (r1 instanceof LiteralPattern && r2 instanceof LiteralPattern) {
-        return r1.name.equals(r2.name);
-    }
-    if (r1 instanceof FunctorPattern && r2 instanceof FunctorPattern) {
-        if (r1.identifier.value !== r2.identifier.value)
-            return false;
-        if (r1.args.length !== r2.args.length)
-            return false;
-        for (let i = 0; i < r1.args.length; i++) {
-            if (!unifyInPlace(r1.args[i], r2.args[i], env))
-                return false;
-        }
-        return true;
-    }
-    if (r1 instanceof ListPattern && r2 instanceof ListPattern) {
-        if (r1.elements.length !== r2.elements.length)
-            return false;
-        for (let i = 0; i < r1.elements.length; i++) {
-            if (!unifyInPlace(r1.elements[i], r2.elements[i], env))
-                return false;
+function unifyParameters(patterns, args, baseSubst, translator, scope, onSuccess, onFailure) {
+    const next = (index, currentSubst) => {
+        if (index >= patterns.length) {
+            return onSuccess(currentSubst);
         }
-        return true;
-    }
-    if (r1 instanceof ConsPattern && r2 instanceof ConsPattern) {
-        let curr1 = r1;
-        let curr2 = r2;
-        while (curr1 instanceof ConsPattern && curr2 instanceof ConsPattern) {
-            if (!unifyInPlace(curr1.left, curr2.left, env))
-                return false;
-            curr1 = resolve(curr1.right, env);
-            curr2 = resolve(curr2.right, env);
-        }
-        return unifyInPlace(curr1, curr2, env);
-    }
-    if (r1 instanceof ConsPattern && r2 instanceof ListPattern) {
-        if (r2.elements.length === 0)
-            return false;
-        const [head, ...tail] = r2.elements;
-        return (unifyInPlace(r1.left, head, env) &&
-            unifyInPlace(r1.right, new ListPattern(tail), env));
-    }
-    if (r1 instanceof ListPattern && r2 instanceof ConsPattern) {
-        if (r1.elements.length === 0)
-            return false;
-        const [head, ...tail] = r1.elements;
-        return (unifyInPlace(head, r2.left, env) &&
-            unifyInPlace(new ListPattern(tail), r2.right, env));
-    }
-    return false;
-}
-/**
- * Follows variable bindings in the substitution map until a non-variable or unbound variable is found.
- */
-export function resolve(node, env) {
-    let current = node;
-    const seen = new Set();
-    while (current instanceof VariablePattern) {
-        const name = current.name.value;
-        if (seen.has(name))
-            break;
-        seen.add(name);
-        const bound = env.get(name);
-        if (!bound)
-            break;
-        current = bound;
-    }
-    return current;
-}
-class Instantiator {
-    substs;
-    seen;
-    constructor(substs, seen = new Set()) {
-        this.substs = substs;
-        this.seen = seen;
-    }
-    visitVariablePattern(node) {
-        const name = node.name.value;
-        if (this.seen.has(name))
-            return node;
-        const val = this.substs.get(name);
-        if (val) {
-            const nextSeen = new Set(this.seen);
-            nextSeen.add(name);
-            return new Instantiator(this.substs, nextSeen).instantiate(val);
-        }
-        return node;
-    }
-    visitLiteralPattern(node) {
-        return node;
-    }
-    visitApplicationPattern(node) {
-        return new ApplicationPattern(node.identifier, node.args.map((arg) => this.instantiate(arg)), node.loc);
-    }
-    visitTuplePattern(node) {
-        return new TuplePattern(node.elements.map((el) => this.instantiate(el)), node.loc);
-    }
-    visitListPattern(node) {
-        return new ListPattern(node.elements.map((el) => this.instantiate(el)), node.loc);
-    }
-    visitFunctorPattern(node) {
-        return new FunctorPattern(node.identifier, node.args.map((arg) => this.instantiate(arg)), node.loc);
-    }
-    visitAsPattern(node) {
-        return new AsPattern(this.instantiate(node.left), this.instantiate(node.right), node.loc);
-    }
-    visitWildcardPattern(node) {
-        return node;
-    }
-    visitUnionPattern(node) {
-        return new UnionPattern(node.elements.map((el) => this.instantiate(el)), node.loc);
-    }
-    visitConstructorPattern(node) {
-        return new ConstructorPattern(node.identifier, node.args.map((arg) => this.instantiate(arg)), node.loc);
-    }
-    visitConsPattern(node) {
-        return new ConsPattern(this.instantiate(node.left), this.instantiate(node.right), node.loc);
-    }
-    visitTypePattern(node) {
-        return new TypePattern(node.targetType, node.innerPattern ? this.instantiate(node.innerPattern) : undefined, node.loc);
-    }
-    instantiate(pattern) {
-        return pattern.accept(this);
-    }
-}
-/**
- * Fully instantiates a pattern by replacing all bound variables with their values.
- */
-export function instantiate(pattern, substs, seen = new Set()) {
-    return new Instantiator(substs, seen).instantiate(pattern);
-}
-let variableCounter = 0;
-class LogicVariableRenamer {
-    renames;
-    freshId;
-    constructor(renames, freshId) {
-        this.renames = renames;
-        this.freshId = freshId;
-    }
-    rename(node) {
-        if (!node || typeof node !== "object")
-            return node;
-        if (typeof node.accept === "function") {
-            return node.accept(this);
-        }
-        return node;
-    }
-    visitFact(node) {
-        return new Fact(node.identifier, node.patterns.map((p) => this.rename(p)), node.loc);
-    }
-    visitRule(node) {
-        const renamedEquations = node.equations.map((eq) => {
-            const body = eq.body;
-            if (!isUnguardedBody(body))
-                throw new Error("GuardedBody renaming not implemented");
-            return new Equation(eq.patterns.map((p) => this.rename(p)), body.accept(this), eq.returnExpr, eq.loc);
-        });
-        return new Rule(node.identifier, renamedEquations, node.loc);
-    }
-    visitUnguardedBody(node) {
-        return new UnguardedBody(new Sequence(node.sequence.statements.map((stmt) => this.rename(stmt)), node.sequence.loc), node.loc);
-    }
-    // PatternVisitor
-    visitVariablePattern(node) {
-        const name = node.name.value;
-        let newName = this.renames.get(name);
-        if (!newName) {
-            newName = `${name}_${this.freshId}`;
-            this.renames.set(name, newName);
-        }
-        return new VariablePattern(new SymbolPrimitive(newName), node.loc);
-    }
-    visitLiteralPattern(node) {
-        return node;
-    }
-    visitApplicationPattern(node) {
-        return new ApplicationPattern(node.identifier, node.args.map((arg) => this.rename(arg)), node.loc);
-    }
-    visitTuplePattern(node) {
-        return new TuplePattern(node.elements.map((el) => this.rename(el)), node.loc);
-    }
-    visitListPattern(node) {
-        return new ListPattern(node.elements.map((el) => this.rename(el)), node.loc);
-    }
-    visitFunctorPattern(node) {
-        return new FunctorPattern(node.identifier, node.args.map((arg) => this.rename(arg)), node.loc);
-    }
-    visitAsPattern(node) {
-        return new AsPattern(this.rename(node.left), this.rename(node.right), node.loc);
-    }
-    visitWildcardPattern(node) {
-        return node;
-    }
-    visitUnionPattern(node) {
-        return new UnionPattern(node.elements.map((el) => this.rename(el)), node.loc);
-    }
-    visitConstructorPattern(node) {
-        return new ConstructorPattern(node.identifier, node.args.map((arg) => this.rename(arg)), node.loc);
-    }
-    visitConsPattern(node) {
-        return new ConsPattern(this.rename(node.left), this.rename(node.right), node.loc);
-    }
-    visitTypePattern(node) {
-        return new TypePattern(node.targetType, node.innerPattern ? this.rename(node.innerPattern) : undefined, node.loc);
-    }
-    // Expression/Statement Visitor
-    visitSymbolPrimitive(node) {
-        const name = node.value;
-        if (/^[A-Z_]/.test(name) && name !== "_") {
-            let newName = this.renames.get(name);
-            if (!newName) {
-                newName = `${name}_${this.freshId}`;
-                this.renames.set(name, newName);
+        const term = translator.patternToTerm(patterns[index], scope);
+        return new BindCommand(term.unify(args[index], currentSubst), (res) => {
+            if (res instanceof YuBoolean && res.value) {
+                return next(index + 1, currentSubst);
             }
-            return new SymbolPrimitive(newName, node.loc);
-        }
-        return node;
-    }
-    visitNumberPrimitive(node) {
-        return node;
-    }
-    visitStringPrimitive(node) {
-        return node;
-    }
-    visitBooleanPrimitive(node) {
-        return node;
-    }
-    visitNilPrimitive(node) {
-        return node;
-    }
-    visitCharPrimitive(node) {
-        return node;
-    }
-    visitGoal(node) {
-        return new Goal(node.identifier, node.args.map((arg) => this.rename(arg)), node.loc);
-    }
-    visitExist(node) {
-        return new Exist(node.identifier, node.patterns.map((pat) => this.rename(pat)), node.loc);
-    }
-    visitFindall(node) {
-        return new Findall(this.rename(node.template), this.rename(node.goal), this.rename(node.bag), node.loc);
-    }
-    visitForall(node) {
-        return new Forall(this.rename(node.condition), this.rename(node.action), node.loc);
-    }
-    visitCall(node) {
-        return new Call(this.rename(node.callee), node.args.map((arg) => this.rename(arg)), node.loc);
-    }
-    visitNot(node) {
-        return new Not(this.rename(node.expression), node.loc);
-    }
-    visitLogicConstraint(node) {
-        return new LogicConstraint(this.rename(node.expression), node.loc);
-    }
-    visitSequence(node) {
-        return new Sequence(node.statements.map((stmt) => this.rename(stmt)), node.loc);
-    }
-    visitIf(node) {
-        return new If(this.rename(node.condition), this.rename(node.then), this.rename(node.elseExpr), node.loc);
-    }
-    visitComparisonOperation(node) {
-        return new ComparisonOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
-    }
-    visitUnifyOperation(node) {
-        return new UnifyOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
-    }
-    visitAssignOperation(node) {
-        return new AssignOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
-    }
-    visitArithmeticBinaryOperation(node) {
-        return new ArithmeticBinaryOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
-    }
-    visitArithmeticUnaryOperation(node) {
-        return new ArithmeticUnaryOperation(node.operator, this.rename(node.operand), node.loc);
-    }
-    visitListBinaryOperation(node) {
-        return new ListBinaryOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
-    }
-    visitListUnaryOperation(node) {
-        return new ListUnaryOperation(node.operator, this.rename(node.operand), node.loc);
-    }
-    visitLogicalBinaryOperation(node) {
-        return new LogicalBinaryOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
-    }
-    visitLogicalUnaryOperation(node) {
-        return new LogicalUnaryOperation(node.operator, this.rename(node.operand), node.loc);
-    }
-    visitBitwiseBinaryOperation(node) {
-        return new BitwiseBinaryOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
-    }
-    visitBitwiseUnaryOperation(node) {
-        return new BitwiseUnaryOperation(node.operator, this.rename(node.operand), node.loc);
-    }
-    visitStringOperation(node) {
-        return new StringOperation(node.operator, this.rename(node.left), this.rename(node.right), node.loc);
-    }
-    visitConsExpression(node) {
-        return new ConsExpression(this.rename(node.head), this.rename(node.tail), node.loc);
-    }
-    visitListPrimitive(node) {
-        return new ListPrimitive(node.value.map((el) => this.rename(el)), node.loc);
-    }
-    visitTupleExpr(node) {
-        return new TupleExpression(node.elements.map((el) => this.rename(el)), node.loc);
-    }
-}
-/**
- * Renames all variables in a Rule or Fact to fresh names to avoid name clashes during unification.
- */
-export function renameVariables(clause) {
-    const renames = new Map();
-    const freshId = ++variableCounter;
-    const renamer = new LogicVariableRenamer(renames, freshId);
-    const renamedClause = clause.accept(renamer);
-    return renamedClause;
+            return onFailure();
+        });
+    };
+    return next(0, new Map(baseSubst));
 }
-class CPSBodyVisitor {
+class KernelBodyVisitor {
     solveBody;
     substs;
-    onSuccess;
-    onNextEq;
-    constructor(solveBody, substs, onSuccess, onNextEq) {
+    scope;
+    constructor(solveBody, substs, scope) {
         this.solveBody = solveBody;
         this.substs = substs;
-        this.onSuccess = onSuccess;
-        this.onNextEq = onNextEq;
+        this.scope = scope;
+    }
+    visitNativeBody(body) {
+        return new StepCommand(YuNil.getInstance());
     }
     visitUnguardedBody(body) {
-        return this.solveBody(body.sequence.statements, this.substs, this.onSuccess, this.onNextEq);
+        return this.solveBody(body.sequence.statements, this.substs, this.scope);
+    }
+    visitGuard(guard) {
+        return new BindCommand(this.solveBody([guard.condition], this.substs, this.scope), (res) => {
+            if (!isLogicResult(res) || !res.allSuccessful())
+                return new BacktrackCommand();
+            const solutions = res.getSuccessfulSolutions();
+            if (solutions.length === 1)
+                return this.solveBody([guard.body], solutions[0], this.scope);
+            return new ChoiceCommand(solutions.map((s) => this.solveBody([guard.body], s, this.scope)));
+        });
     }
-    visitGuardedBody(body) {
-        return this.solveBody([body.condition], this.substs, (guardSubsts, _nextGuardChoice) => {
-            return this.solveBody([body.body], guardSubsts, this.onSuccess, this.onNextEq);
-        }, this.onNextEq);
+    fallback(node) {
+        return new FailCommand(new InterpreterError("Logic", `Unexpected node ${node.constructor.name} in equation body`));
     }
 }
-class GoalSolverVisitor {
+export class GoalKernelVisitor {
     args;
     baseSubst;
     solveBody;
-    onSuccess;
-    onNextClause;
-    constructor(args, baseSubst, solveBody, onSuccess, onNextClause) {
+    translator;
+    constructor(args, baseSubst, solveBody, translator) {
         this.args = args;
         this.baseSubst = baseSubst;
         this.solveBody = solveBody;
-        this.onSuccess = onSuccess;
-        this.onNextClause = onNextClause;
+        this.translator = translator;
     }
     visitFact(fact) {
-        if (fact.patterns.length !== this.args.length)
-            return this.onNextClause;
-        const renamedFact = renameVariables(fact);
-        const substs = unifyParameters(renamedFact.patterns, this.args, this.baseSubst);
-        if (substs)
-            return this.onSuccess(substs, this.onNextClause);
-        return this.onNextClause;
+        const scope = new Map();
+        const onSuccess = (substs) => new StepCommand(new LogicResult([new LogicAnswer(true, substs)]));
+        return unifyParameters(fact.patterns, this.args, this.baseSubst, this.translator, scope, onSuccess, () => new BacktrackCommand());
     }
     visitRule(rule) {
-        if (rule.equations.length === 0)
-            return this.onNextClause;
-        const arity = rule.equations[0].patterns.length;
-        if (arity !== this.args.length)
-            return this.onNextClause;
-        const renamedRule = renameVariables(rule);
-        const tryRuleEq = (eqIndex) => {
-            if (eqIndex >= renamedRule.equations.length)
-                return this.onNextClause;
-            const eq = renamedRule.equations[eqIndex];
-            const substs = unifyParameters(eq.patterns, this.args, this.baseSubst);
-            const onNextEq = () => tryRuleEq(eqIndex + 1);
-            if (!substs)
-                return onNextEq;
-            const bodyVisitor = new CPSBodyVisitor(this.solveBody, substs, this.onSuccess, onNextEq);
-            if (isUnguardedBody(eq.body))
-                return eq.body.accept(bodyVisitor);
-            return eq.body.forEach((branch) => branch.accept(bodyVisitor));
+        const tryEquation = (eqIndex) => {
+            if (eqIndex >= rule.equations.length) {
+                return new BacktrackCommand();
+            }
+            const eq = rule.equations[eqIndex];
+            const scope = new Map();
+            const onFailure = () => tryEquation(eqIndex + 1);
+            const onSuccess = (substs) => {
+                const bodyVisitor = new KernelBodyVisitor(this.solveBody, substs, scope);
+                const currentCmd = eq.body.accept(bodyVisitor);
+                return new ChoiceCommand([currentCmd, tryEquation(eqIndex + 1)]);
+            };
+            return unifyParameters(eq.patterns, this.args, this.baseSubst, this.translator, scope, onSuccess, onFailure);
         };
-        return () => tryRuleEq(0);
+        return tryEquation(0);
     }
-}
-/**
- * Solves a single logic goal (predicate call) using CPS.
- */
-export function solveGoalCPS(ctx, predicateName, args, solveBody, baseSubst, onSuccess, onFailure) {
-    const tryClause = (index) => {
-        let equations;
-        try {
-            const pred = ctx.lookup(predicateName);
-            if (!pred || !isRuntimePredicate(pred))
-                return () => onFailure();
-            equations = pred.equations;
-        }
-        catch (error) {
-            return () => onFailure();
-        }
-        if (index >= equations.length)
-            return () => onFailure();
-        const clause = equations[index];
-        const onNextClause = () => tryClause(index + 1);
-        const clauseVisitor = new GoalSolverVisitor(args, baseSubst, solveBody, onSuccess, onNextClause);
-        return clause.accept(clauseVisitor);
-    };
-    return () => tryClause(0);
-}
-/**
- * Unifies two lists of parameters. Returns the resulting Substitution or null.
- */
-function unifyParameters(patterns, args, baseSubst) {
-    let subst = new Map(baseSubst);
-    for (let i = 0; i < patterns.length; i++) {
-        const nextSubst = unify(patterns[i], args[i], subst);
-        if (!nextSubst)
-            return null;
-        subst = nextSubst;
+    fallback(node) {
+        return new FailCommand(new InterpreterError("Logic", `Unexpected node ${node.constructor.name} in predicate definition`));
     }
-    return subst;
 }
 /**
- * Solves a findall/3 goal using CPS.
+ * Solves a single logic goal (predicate call) using the Kernel.
+ * Returns a non-deterministic command. Aggregation should happen at top-level.
  */
-export function solveFindallCPS(node, currentSubsts, solveBody, onSuccess, onFailure) {
-    const gathered = [];
-    const collectResults = () => {
-        return solveBody([node.goal], currentSubsts, (resultSubsts, next) => {
-            gathered.push(instantiate(node.template, resultSubsts));
-            return () => next();
-        }, () => {
-            const resultList = new ListPattern(gathered);
-            const finalSubsts = unify(node.bag, resultList, currentSubsts);
-            if (finalSubsts) {
-                return onSuccess(finalSubsts, onFailure);
-            }
-            return () => onFailure();
-        });
-    };
-    return collectResults();
+export function solveGoalKernel(ctx, predicateName, args, solveBody, baseSubst, translator) {
+    const pred = ctx.isDefined(predicateName) ? ctx.lookup(predicateName) : null;
+    const validPredicate = isRuntimePredicate(pred) && pred.validateArity(args.length);
+    if (!validPredicate)
+        return new BacktrackCommand();
+    const visitor = new GoalKernelVisitor(args, baseSubst, solveBody, translator);
+    const choices = pred
+        .apply(visitor)
+        .filter((c) => !(c instanceof FailCommand));
+    if (choices.length === 0)
+        return new BacktrackCommand();
+    return choices.length === 1 ? choices[0] : new ChoiceCommand(choices);
 }

package/dist/interpreter/components/logic/LogicTerm.d.ts

@@ -0,0 +1,104 @@
+import { YuValue } from "../../primitives/index.js";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { LogicTerm, Substitution } from "../../primitives/entities/LogicResult.js";
+/**
+ * Represents a logic variable with a unique numeric ID.
+ */
+export declare class VariableTerm extends LogicTerm {
+    readonly id: number;
+    readonly name: string;
+    readonly logicTermType = "Variable";
+    constructor(id: number, name: string);
+    getType(): string;
+    toJSON(): unknown;
+    resolve(env: Substitution): LogicTerm;
+    unify(other: LogicTerm, env: Substitution): ExecutionCommand;
+    occurs(v: VariableTerm, env: Substitution): boolean;
+    instantiate(env: Substitution, seen?: Set<number>): LogicTerm;
+    toPrimitive(env: Substitution): YuValue;
+    toString(): string;
+}
+/**
+ * Represents a constant value (Numbers, Strings, Booleans).
+ */
+export declare class ConstantTerm extends LogicTerm {
+    readonly value: YuValue;
+    readonly logicTermType = "Constant";
+    constructor(value: YuValue);
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    getType(): string;
+    toJSON(): unknown;
+    resolve(): LogicTerm;
+    occurs(): boolean;
+    unify(other: LogicTerm, env: Substitution): ExecutionCommand;
+    instantiate(): LogicTerm;
+    toPrimitive(): YuValue;
+    toString(): string;
+}
+/**
+ * Represents a compound structure (Functors, Constructors, Application).
+ */
+export declare class CompoundTerm extends LogicTerm {
+    readonly functor: string;
+    readonly args: LogicTerm[];
+    readonly logicTermType = "Compound";
+    constructor(functor: string, args: LogicTerm[]);
+    getType(): string;
+    toJSON(): unknown;
+    resolve(): LogicTerm;
+    occurs(v: VariableTerm, env: Substitution): boolean;
+    unify(other: LogicTerm, env: Substitution): ExecutionCommand;
+    instantiate(env: Substitution, seen?: Set<number>): LogicTerm;
+    toPrimitive(env: Substitution): YuValue;
+    toString(): string;
+}
+/**
+ * Represents the wildcard pattern (_).
+ */
+export declare class WildcardTerm extends LogicTerm {
+    readonly logicTermType = "Wildcard";
+    equals(other: YuValue): ExecutionCommand;
+    compare(other: YuValue): ExecutionCommand;
+    getType(): string;
+    toJSON(): unknown;
+    resolve(): LogicTerm;
+    occurs(): boolean;
+    unify(other: LogicTerm, env: Substitution): ExecutionCommand;
+    instantiate(): LogicTerm;
+    toPrimitive(): YuValue;
+    toString(): string;
+}
+/**
+ * Represents a List [x, y, z].
+ */
+export declare class ListTerm extends LogicTerm {
+    readonly elements: LogicTerm[];
+    readonly logicTermType = "List";
+    constructor(elements: LogicTerm[]);
+    getType(): string;
+    toJSON(): unknown;
+    resolve(): LogicTerm;
+    occurs(v: VariableTerm, env: Substitution): boolean;
+    unify(other: LogicTerm, env: Substitution): ExecutionCommand;
+    instantiate(env: Substitution, seen?: Set<number>): LogicTerm;
+    toPrimitive(env: Substitution): YuValue;
+    toString(): string;
+}
+/**
+ * Represents a Cons cell (head:tail).
+ */
+export declare class ConsTerm extends LogicTerm {
+    readonly head: LogicTerm;
+    readonly tail: LogicTerm;
+    readonly logicTermType = "Cons";
+    constructor(head: LogicTerm, tail: LogicTerm);
+    getType(): string;
+    toJSON(): unknown;
+    resolve(): LogicTerm;
+    occurs(v: VariableTerm, env: Substitution): boolean;
+    unify(other: LogicTerm, env: Substitution): ExecutionCommand;
+    instantiate(env: Substitution, seen?: Set<number>): LogicTerm;
+    toPrimitive(env: Substitution): YuValue;
+    toString(): string;
+}