yukigo 0.2.2 → 0.3.1

package/tests/interpreter/LogicEngine.spec.ts

@@ -1,327 +1,371 @@
-import { expect } from "chai";
-import {
-  SymbolPrimitive,
-  NumberPrimitive,
-  LiteralPattern,
-  VariablePattern,
-  Fact,
-  Findall,
-  Goal,
-  Pattern,
-  Rule,
-  LogicResult,
-  EnvStack,
-  Equation,
-  Sequence,
-  UnguardedBody,
-  Statement,
-  Variable,
-  ConsPattern,
-  ListPattern,
-  NilPrimitive,
-  LazyList,
-  LogicConstraint,
-  Expression,
-  SuccessLogicResult,
-  RuntimePredicate,
-} from "yukigo-ast";
-import {
-  createGlobalEnv,
-  ExpressionEvaluator,
-} from "../../src/interpreter/utils.js";
-import { LogicEngine } from "../../src/interpreter/components/logic/LogicEngine.js";
-import { unify } from "../../src/interpreter/components/logic/LogicResolver.js";
-import { PatternResolver } from "../../src/interpreter/components/PatternMatcher.js";
-import { InterpreterVisitor } from "../../src/interpreter/components/Visitor.js";
-import {
-  idContinuation,
-  trampoline,
-} from "../../src/interpreter/trampoline.js";
-import {
-  InterpreterConfig,
-  RuntimeContext,
-} from "../../src/interpreter/components/RuntimeContext.js";
-
-const s = (val: string) => new SymbolPrimitive(val);
-const n = (val: number) => new NumberPrimitive(val);
-const lit = (val: string | number) =>
-  new LiteralPattern(typeof val === "string" ? s(val) : n(val));
-const varPat = (name: string) => new VariablePattern(s(name));
-
-const makeEq = (args: Pattern[], stmts: Statement[]) =>
-  new Equation(args, new UnguardedBody(new Sequence(stmts)));
-const makeFact = (id: string, args: Pattern[]) => new Fact(s(id), args);
-const makeRule = (id: string, body: Equation[]) => new Rule(s(id), body);
-const makeGoal = (id: string, args: Pattern[]) => new Goal(s(id), args);
-const makeConstraint = (expr: Expression) => new LogicConstraint(expr);
-
-const factsParent: RuntimePredicate = {
-  kind: "Fact",
-  identifier: "parent",
-  equations: [
-    makeFact("parent", [lit("zeus"), lit("ares")]),
-    makeFact("parent", [lit("zeus"), lit("athena")]),
-    makeFact("parent", [lit("hera"), lit("ares")]),
-  ],
-};
-const rulesSibling: RuntimePredicate = {
-  kind: "Rule",
-  identifier: "sibling",
-  equations: [
-    makeRule("sibling", [
-      makeEq(
-        [varPat("X"), varPat("Y")],
-        [
-          makeConstraint(makeGoal("parent", [varPat("Z"), varPat("X")])),
-          makeConstraint(makeGoal("parent", [varPat("Z"), varPat("Y")])),
-        ],
-      ),
-    ]),
-  ],
-};
-
-const env = createGlobalEnv();
-const context = new RuntimeContext({
-  debug: false,
-  outputMode: "all",
-});
-context.setEnv(env);
-context.define("sibling", rulesSibling);
-context.define("parent", factsParent);
-
-describe("Logic Engine & Unification", () => {
-  let engine: LogicEngine;
-  let evaluator: ExpressionEvaluator;
-
-  beforeEach(() => {
-    evaluator = new InterpreterVisitor(context);
-    engine = new LogicEngine(evaluator, context);
-  });
-
-  describe("Unification Algorithm", () => {
-    it("should unify two identical literals", () => {
-      const p1 = lit("cat");
-      const p2 = lit("cat");
-      const result = unify(p1, p2);
-      expect(result).to.not.be.null;
-    });
-
-    it("should not unify different literals", () => {
-      const p1 = lit("cat");
-      const p2 = lit("dog");
-      const result = unify(p1, p2);
-      expect(result).to.be.null;
-    });
-
-    it("should unify a variable with a literal", () => {
-      const v1 = varPat("X");
-      const p2 = lit("cat");
-      const result = unify(v1, p2);
-
-      expect(result).to.not.be.null;
-      const resolved = result!.get("X");
-      expect(resolved).to.be.instanceOf(LiteralPattern);
-      const resolver = new PatternResolver();
-      expect(resolved?.accept(resolver)).to.equal("cat");
-    });
-
-    it("should unify two variables (aliasing)", () => {
-      const v1 = varPat("X");
-      const v2 = varPat("Y");
-      const result = unify(v1, v2);
-      expect(result).to.not.be.null;
-      expect(result!.has("X")).to.be.true;
-    });
-
-    describe("ConsPattern Unification", () => {
-      it("should unify two identical ConsPatterns", () => {
-          const p1 = new ConsPattern(lit(1), new ListPattern([]));
-          const p2 = new ConsPattern(lit(1), new ListPattern([]));
-          const result = unify(p1, p2);
-          expect(result).to.not.be.null;
-      });
-
-      it("should unify ConsPattern with equivalent ListPattern", () => {
-          const cons = new ConsPattern(lit(1), new ListPattern([lit(2)]));
-          const list = new ListPattern([lit(1), lit(2)]);
-          const result = unify(cons, list);
-          expect(result).to.not.be.null;
-      });
-
-      it("should unify ListPattern with equivalent ConsPattern", () => {
-          const list = new ListPattern([lit(1), lit(2)]);
-          const cons = new ConsPattern(lit(1), new ListPattern([lit(2)]));
-          const result = unify(list, cons);
-          expect(result).to.not.be.null;
-      });
-
-      it("should fail if heads do not match", () => {
-          const cons = new ConsPattern(lit(1), new ListPattern([lit(2)]));
-          const list = new ListPattern([lit(3), lit(2)]);
-          const result = unify(cons, list);
-          expect(result).to.be.null;
-      });
-      
-      it("should fail if ListPattern is empty and ConsPattern expects head", () => {
-          const list = new ListPattern([]);
-          const cons = new ConsPattern(varPat("H"), varPat("T"));
-          const result = unify(list, cons);
-          expect(result).to.be.null;
-      });
-
-      it("should bind variables in ConsPattern", () => {
-          const cons = new ConsPattern(varPat("H"), varPat("T"));
-          const list = new ListPattern([lit(1), lit(2)]);
-          const result = unify(cons, list);
-          expect(result).to.not.be.null;
-          
-          const h = result!.get("H");
-          expect(h).to.be.instanceOf(LiteralPattern);
-          
-          const t = result!.get("T");
-          expect(t).to.be.instanceOf(ListPattern);
-          expect((t as ListPattern).elements).to.have.lengthOf(1);
-      });
-
-      it("should unify infinite LazyList with Variable lazily", () => {
-         // Create infinite generator
-         const gen = function*() {
-             let i = 1;
-             while(true) yield i++;
-         };
-         const lazyList: LazyList = {
-             type: "LazyList",
-             generator: gen
-         };
-
-         // Mock evaluator to return this lazy list for variable "Infinite"
-         evaluator.evaluate = (node: any) => {
-             if (node instanceof Variable && node.identifier.value === "Infinite") {
-                 return lazyList;
-             }
-             if (node instanceof SymbolPrimitive) return node.value;
-             return null;
-         };
-         
-         // Unify X = Infinite
-         const infiniteVar = new Variable(s("Infinite"), new NilPrimitive(null));
-         const xVar = new Variable(s("X"), new NilPrimitive(null));
-         
-         const result = trampoline(engine.unifyExpr(xVar, infiniteVar, idContinuation)) as boolean;
-         expect(result).to.be.true;
-      });
-    });
-  });
-
-  describe("LogicEngine Execution", () => {
-    it("should solve a simple ground goal (Fact exists)", () => {
-      const query = makeGoal("parent", [lit("zeus"), lit("ares")]);
-      const results = trampoline(
-        engine.solveGoal(query, idContinuation),
-      ) as LogicResult[];
-      expect(results).to.not.be.false;
-      results.forEach((res) => expect(res.success).to.be.true);
-    });
-
-    it("should fail a ground goal that does not exist", () => {
-      const query = makeGoal("parent", [lit("zeus"), lit("thor")]);
-      const results = trampoline(
-        engine.solveGoal(query, idContinuation),
-      ) as LogicResult[];
-      results.forEach((res) => expect(res.success).to.be.false);
-    });
-
-    it("should solve a goal with a variable", () => {
-      const query = makeGoal("parent", [lit("zeus"), varPat("Child")]);
-      const results = trampoline(
-        engine.solveGoal(query, idContinuation),
-      ) as LogicResult[];
-
-      results.forEach((res) => {
-        if (!res.success) expect.fail("Result should be successful");
-        expect(res.solutions.has("Child")).to.be.true;
-      });
-
-      const names = results.map((r) => {
-        if (!r.success) throw new Error("Unexpected failure");
-        return r.solutions.get("Child");
-      });
-
-      expect(names).to.include("ares");
-      expect(names).to.include("athena");
-    });
-
-    it("should solve a rule using backtracking", () => {
-      const query = makeGoal("sibling", [lit("ares"), lit("athena")]);
-      const results = trampoline(
-        engine.solveGoal(query, idContinuation),
-      ) as LogicResult[];
-      expect(results.length).to.be.eq(1);
-      const solution = results[0] as SuccessLogicResult;
-      expect(solution.success).to.be.true;
-      expect(solution.solutions.get("X")).to.eq("ares");
-      expect(solution.solutions.get("Y")).to.eq("athena");
-      expect(solution.solutions.get("Z")).to.eq("zeus");
-    });
-  });
-  it("should solve a rule using backtracking with variable", () => {
-    const query = makeGoal("sibling", [lit("ares"), varPat("Child")]);
-    const results = trampoline(
-      engine.solveGoal(query, idContinuation),
-    ) as LogicResult[];
-    results.forEach((res) => {
-      if (!res.success) expect.fail("Result should be successful");
-      expect(res.solutions.has("Child")).to.be.true;
-    });
-    const names = results.map((r) => {
-      if (!r.success) throw new Error("Unexpected failure");
-      return r.solutions.get("Child");
-    });
-    expect(names).to.include("ares");
-    expect(names).to.include("athena");
-  });
-  describe("Output Modes", () => {
-    it('should return all results when outputMode is "all"', () => {
-      const query = makeGoal("parent", [lit("zeus"), varPat("X")]);
-
-      const results = trampoline(
-        engine.solveGoal(query, idContinuation),
-      ) as LogicResult[];
-      expect(results).to.be.an("array");
-      expect(results).to.have.lengthOf(2);
-      const names = results.map((r) => {
-        if (!r.success) throw new Error("Unexpected failure");
-        return r.solutions.get("X");
-      });
-      expect(names).to.include("ares");
-      expect(names).to.include("athena");
-    });
-  });
-
-  describe("Findall", () => {
-    it("should collect all solutions into a list", () => {
-      const findallNode = new Findall(
-        varPat("X"), // Template
-        makeGoal("parent", [lit("zeus"), varPat("X")]), // Goal
-        varPat("List"), // Bag variable
-      );
-      const result = trampoline(
-        engine.solveFindall(findallNode, idContinuation),
-      ) as any;
-      expect(Array.isArray(result)).to.be.true;
-      expect(result).to.have.lengthOf(2);
-      expect(result).to.include("ares");
-      expect(result).to.include("athena");
-    });
-
-    describe("Expression Unification", () => {
-      it("should successfully unify a variable with an array expression", () => {
-        env.head.set("myList", "dummy");
-        const X = new Variable(s("X"), new NilPrimitive(null));
-        const myList = new Variable(s("myList"), new NilPrimitive(null));
-        const result = trampoline(engine.unifyExpr(X, myList, idContinuation));
-        expect(result).to.be.true;
-      });
-    });
-  });
-});
+import { expect } from "chai";
+import {
+  SymbolPrimitive,
+  NumberPrimitive,
+  LiteralPattern,
+  VariablePattern,
+  Fact,
+  Findall,
+  Goal,
+  Pattern,
+  Rule,
+  Equation,
+  Sequence,
+  UnguardedBody,
+  Statement,
+  Variable,
+  NilPrimitive,
+  LogicConstraint,
+  Expression,
+  Query,
+} from "yukigo-ast";
+import { createGlobalEnv } from "../../src/interpreter/utils.js";
+import { LogicEngine } from "../../src/interpreter/components/logic/LogicEngine.js";
+import { RuntimeContext } from "../../src/interpreter/components/RuntimeContext.js";
+import { YukigoKernel } from "../../src/interpreter/components/kernel/index.js";
+import { StepCommand } from "../../src/interpreter/components/kernel/commands.js";
+import {
+  VariableTerm,
+  ConstantTerm,
+  ListTerm,
+  ConsTerm,
+  CompoundTerm,
+} from "../../src/interpreter/components/logic/LogicTerm.js";
+import {
+  YuValue,
+  RuntimePredicate,
+  LogicTerm,
+  Substitution,
+  YuString,
+  YuNumber,
+  LazyList,
+  LazyStepResult,
+  YuNil,
+  LogicResult,
+  YuBoolean,
+} from "../../src/interpreter/primitives/index.js";
+import { InterpreterVisitor } from "../../src/interpreter/components/evaluators/index.js";
+
+const s = (val: string) => new SymbolPrimitive(val);
+const n = (val: number) => new NumberPrimitive(val);
+const lit = (val: string | number) =>
+  new LiteralPattern(typeof val === "string" ? s(val) : n(val));
+const varPat = (name: string) => new VariablePattern(s(name));
+
+const makeEq = (args: Pattern[], stmts: Statement[]) =>
+  new Equation(args, new UnguardedBody(new Sequence(stmts)));
+const makeFact = (id: string, args: Pattern[]) => new Fact(s(id), args);
+const makeRule = (id: string, body: Equation[]) => new Rule(s(id), body);
+const makeGoal = (id: string, args: Pattern[]) => new Goal(s(id), args);
+const makeConstraint = (expr: Expression) => new LogicConstraint(expr);
+
+const factsParent = new RuntimePredicate("parent", [
+  makeFact("parent", [lit("zeus"), lit("ares")]),
+  makeFact("parent", [lit("zeus"), lit("athena")]),
+  makeFact("parent", [lit("hera"), lit("ares")]),
+]);
+const rulesSibling = new RuntimePredicate("sibling", [
+  makeRule("sibling", [
+    makeEq(
+      [varPat("X"), varPat("Y")],
+      [
+        makeConstraint(makeGoal("parent", [varPat("Z"), varPat("X")])),
+        makeConstraint(makeGoal("parent", [varPat("Z"), varPat("Y")])),
+      ],
+    ),
+  ]),
+]);
+
+describe("Logic Engine & Unification", () => {
+  let engine: LogicEngine;
+  let evaluator: InterpreterVisitor;
+  let kernel: YukigoKernel;
+  let context: RuntimeContext;
+  let globalEnv: any;
+
+  beforeEach(() => {
+    globalEnv = createGlobalEnv();
+    context = new RuntimeContext({
+      debug: false,
+      outputMode: "all",
+    });
+    context.setEnv(globalEnv);
+    context.define("sibling", rulesSibling);
+    context.define("parent", factsParent);
+    evaluator = new InterpreterVisitor(context);
+    engine = new LogicEngine(evaluator, context);
+    kernel = new YukigoKernel(evaluator, "all");
+  });
+
+  const unify = (
+    t1: LogicTerm,
+    t2: LogicTerm,
+    substs: Substitution = new Map(),
+  ) => {
+    const cmd = t1.unify(t2, substs);
+    const k = new YukigoKernel(evaluator, "first");
+    const res = k.run(cmd);
+    if (res instanceof YuBoolean && res.value) {
+      return substs;
+    }
+    return null;
+  };
+
+  describe("Unification Algorithm", () => {
+    it("should unify two identical literals", () => {
+      const p1 = new ConstantTerm(new YuString("cat"));
+      const p2 = new ConstantTerm(new YuString("cat"));
+      const result = unify(p1, p2);
+      expect(result).to.not.be.null;
+    });
+
+    it("should not unify different literals", () => {
+      const p1 = new ConstantTerm(new YuString("cat"));
+      const p2 = new ConstantTerm(new YuString("dog"));
+      const result = unify(p1, p2);
+      expect(result).to.be.null;
+    });
+
+    it("should unify a variable with a literal", () => {
+      const v1 = new VariableTerm(1, "X");
+      const p2 = new ConstantTerm(new YuString("cat"));
+      const result = unify(v1, p2);
+
+      expect(result).to.not.be.null;
+      const resolved = v1.resolve(result!);
+      expect(resolved).to.be.instanceOf(ConstantTerm);
+      expect((resolved as ConstantTerm).value.toJSON()).to.equal("cat");
+    });
+
+    it("should unify two variables (aliasing)", () => {
+      const v1 = new VariableTerm(1, "X");
+      const v2 = new VariableTerm(2, "Y");
+      const result = unify(v1, v2);
+      expect(result).to.not.be.null;
+      expect(result!.has(1)).to.be.true;
+    });
+
+    describe("ConsPattern Unification", () => {
+      it("should unify two identical ConsPatterns", () => {
+        const p1 = new ConsTerm(
+          new ConstantTerm(new YuNumber(1)),
+          new ListTerm([]),
+        );
+        const p2 = new ConsTerm(
+          new ConstantTerm(new YuNumber(1)),
+          new ListTerm([]),
+        );
+        const result = unify(p1, p2);
+        expect(result).to.not.be.null;
+      });
+
+      it("should unify ConsPattern with equivalent ListPattern", () => {
+        const cons = new ConsTerm(
+          new ConstantTerm(new YuNumber(1)),
+          new ListTerm([new ConstantTerm(new YuNumber(2))]),
+        );
+        const list = new ListTerm([
+          new ConstantTerm(new YuNumber(1)),
+          new ConstantTerm(new YuNumber(2)),
+        ]);
+        const result = unify(cons, list);
+        expect(result).to.not.be.null;
+      });
+
+      it("should unify ListPattern with equivalent ConsPattern", () => {
+        const list = new ListTerm([
+          new ConstantTerm(new YuNumber(1)),
+          new ConstantTerm(new YuNumber(2)),
+        ]);
+        const cons = new ConsTerm(
+          new ConstantTerm(new YuNumber(1)),
+          new ListTerm([new ConstantTerm(new YuNumber(2))]),
+        );
+        const result = unify(list, cons);
+        expect(result).to.not.be.null;
+      });
+
+      it("should fail if heads do not match", () => {
+        const cons = new ConsTerm(
+          new ConstantTerm(new YuNumber(1)),
+          new ListTerm([new ConstantTerm(new YuNumber(2))]),
+        );
+        const list = new ListTerm([
+          new ConstantTerm(new YuNumber(3)),
+          new ConstantTerm(new YuNumber(2)),
+        ]);
+        const result = unify(cons, list);
+        expect(result).to.be.null;
+      });
+
+      it("should fail if ListPattern is empty and ConsPattern expects head", () => {
+        const list = new ListTerm([]);
+        const cons = new ConsTerm(
+          new VariableTerm(1, "H"),
+          new VariableTerm(2, "T"),
+        );
+        const result = unify(list, cons);
+        expect(result).to.be.null;
+      });
+
+      it("should bind variables in ConsPattern", () => {
+        const list = new ListTerm([
+          new ConstantTerm(new YuNumber(1)),
+          new ConstantTerm(new YuNumber(2)),
+        ]);
+
+        const vH = new VariableTerm(1, "H");
+        const vT = new VariableTerm(2, "T");
+        const cons = new ConsTerm(vH, vT);
+        const result = unify(cons, list) as Substitution;
+        expect(result).to.not.be.null;
+
+        const h = vH.resolve(result);
+        expect(h).to.be.instanceOf(ConstantTerm);
+
+        const t = vT.resolve(result);
+        expect(t).to.be.instanceOf(ListTerm);
+        expect((t as ListTerm).elements).to.have.lengthOf(1);
+      });
+
+      it("should fail unification with occurs check (circularity)", () => {
+        const vX = new VariableTerm(1, "X");
+        const compound = new CompoundTerm("f", [vX]);
+        const result = unify(vX, compound);
+        expect(result).to.be.null;
+      });
+
+      it("should unify infinite LazyList with Variable lazily", () => {
+        const createLazyRange = (val: number): LazyList => {
+          return new LazyList(() => {
+            return new StepCommand(
+              new LazyStepResult(new YuNumber(val), createLazyRange(val + 1)),
+            );
+          }, `Range(${val})`);
+        };
+
+        const lazyList = createLazyRange(1);
+
+        evaluator.evaluate = (node: any) => {
+          if (
+            node instanceof Variable &&
+            node.identifier.value === "Infinite"
+          ) {
+            return new StepCommand(lazyList);
+          }
+          if (node instanceof SymbolPrimitive)
+            return new StepCommand(new YuString(node.value));
+          return new StepCommand(YuNil.getInstance());
+        };
+
+        const infiniteVar = new Variable(s("Infinite"), new NilPrimitive(null));
+        const xVar = new Variable(s("X"), new NilPrimitive(null));
+
+        const result = kernel.run(
+          engine.unifyExpr(xVar, infiniteVar),
+        ) as YuValue[];
+        expect(result[0].toJSON()).to.be.true;
+      });
+    });
+  });
+
+  describe("LogicEngine Execution", () => {
+    it("should solve a simple ground goal (Fact exists)", () => {
+      const query = makeGoal("parent", [lit("zeus"), lit("ares")]);
+      const results = kernel.run(engine.solveGoalLike(query)) as LogicResult[];
+      expect(results[0].success).to.be.true;
+    });
+
+    it("should fail a ground goal that does not exist", () => {
+      const query = makeGoal("parent", [lit("zeus"), lit("thor")]);
+      const results = kernel.run(engine.solveGoalLike(query)) as LogicResult[];
+      expect(results).to.be.empty;
+    });
+
+    it("should solve a goal with a variable", () => {
+      const goal = makeGoal("parent", [lit("zeus"), varPat("Child")]);
+      const query = new Query([goal]);
+      const results = kernel.run(engine.solveQuery(query)) as LogicResult[];
+
+      expect(results.every((res) => res.allSuccessful())).to.be.true;
+
+      const names = results.map((res) =>
+        (res.solutions.get("Child") as ConstantTerm).value.toJSON(),
+      );
+
+      expect(names).to.include("ares");
+      expect(names).to.include("athena");
+    });
+
+    it("should solve a rule using backtracking", () => {
+      const query = makeGoal("sibling", [lit("ares"), lit("athena")]);
+      const results = kernel.run(engine.solveGoalLike(query)) as LogicResult[];
+      expect(results[0].success).to.be.true;
+    });
+  });
+
+  it("should solve a rule using backtracking with variable", () => {
+    const goal = makeGoal("sibling", [lit("ares"), varPat("Child")]);
+    const query = new Query([goal]);
+    const results = kernel.run(engine.solveQuery(query)) as LogicResult[];
+    expect(results.every((res) => res.allSuccessful())).to.be.true;
+    const names = results.map((res) =>
+      (res.solutions.get("Child") as ConstantTerm).value.toJSON(),
+    );
+    expect(names).to.include("ares");
+    expect(names).to.include("athena");
+  });
+
+  describe("Output Modes", () => {
+    it('should return all results when outputMode is "all"', () => {
+      const goal = makeGoal("parent", [lit("zeus"), varPat("X")]);
+      const query = new Query([goal]);
+      const results = kernel.run(engine.solveQuery(query)) as LogicResult[];
+      expect(results[0]).to.be.instanceOf(LogicResult);
+      expect(results[1]).to.be.instanceOf(LogicResult);
+      const names = results.map((res) =>
+        (res.solutions.get("X") as ConstantTerm).value.toJSON(),
+      );
+      expect(names).to.include("ares");
+      expect(names).to.include("athena");
+    });
+  });
+
+  describe("Findall", () => {
+    it("should collect all solutions into a list", () => {
+      const findallNode = new Findall(
+        varPat("X"),
+        makeGoal("parent", [lit("zeus"), varPat("X")]),
+        varPat("List"),
+      );
+
+      const queryNode = new Query([findallNode]);
+      const results = kernel.run(engine.solveQuery(queryNode)) as LogicResult[];
+      const firstResult = results[0];
+      expect(firstResult.allSuccessful()).to.be.true;
+
+      const answer = firstResult.allAnswers[0];
+      const solution = answer.getSolution();
+
+      const list = solution.get("List") as ListTerm;
+      expect(list).to.not.be.undefined;
+
+      const names = list.elements.map((el) =>
+        (el as ConstantTerm).value.toJSON(),
+      );
+      expect(names).to.have.lengthOf(2);
+      expect(names).to.include("ares");
+      expect(names).to.include("athena");
+    });
+
+    describe("Expression Unification", () => {
+      it("should successfully unify a variable with an array expression", () => {
+        globalEnv.head.set("myList", new YuString("dummy"));
+        const X = new Variable(s("X"), new NilPrimitive(null));
+        const myList = new Variable(s("myList"), new NilPrimitive(null));
+        const result = kernel.run(engine.unifyExpr(X, myList)) as YuValue[];
+        expect(result[0].toJSON()).to.be.true;
+      });
+    });
+  });
+});