yukigo 0.2.3 → 0.3.2

package/tests/interpreter/LogicSubstitution.spec.ts

@@ -1,80 +1,90 @@
-import { expect } from "chai";
-import {
-  SymbolPrimitive,
-  NumberPrimitive,
-  LiteralPattern,
-  VariablePattern,
-  ListPattern,
-  ConsPattern,
-  FunctorPattern,
-  Pattern,
-} from "yukigo-ast";
-import {
-  instantiate,
-  Substitution,
-} from "../../src/interpreter/components/logic/LogicResolver.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));
-
-describe("Logic Substitution (instantiate)", () => {
-  it("should recursively substitute in ListPattern", () => {
-    const pattern = new ListPattern([varPat("X"), lit(1), varPat("Y")]);
-    const substs: Substitution = new Map([
-      ["X", lit("cat")],
-      ["Y", lit("dog")],
-    ]);
-
-    const result = instantiate(pattern, substs) as ListPattern;
-    expect(result).to.be.instanceOf(ListPattern);
-    expect(result.elements[0]).to.deep.equal(lit("cat"));
-    expect(result.elements[1]).to.deep.equal(lit(1));
-    expect(result.elements[2]).to.deep.equal(lit("dog"));
-  });
-
-  it("should recursively substitute in ConsPattern", () => {
-    const pattern = new ConsPattern(varPat("X"), varPat("Y"));
-    const substs: Substitution = new Map<string, Pattern>([
-      ["X", lit(1)],
-      ["Y", new ListPattern([lit(2), lit(3)])],
-    ]);
-
-    const result = instantiate(pattern, substs) as ConsPattern;
-    expect(result).to.be.instanceOf(ConsPattern);
-    expect(result.left).to.deep.equal(lit(1));
-    expect(result.right).to.be.instanceOf(ListPattern);
-    expect((result.right as ListPattern).elements).to.have.lengthOf(2);
-  });
-
-  it("should recursively substitute in FunctorPattern", () => {
-    const pattern = new FunctorPattern(s("person"), [
-      varPat("Name"),
-      varPat("Age"),
-    ]);
-    const substs: Substitution = new Map([
-      ["Name", lit("Alice")],
-      ["Age", lit(30)],
-    ]);
-
-    const result = instantiate(pattern, substs) as FunctorPattern;
-    expect(result).to.be.instanceOf(FunctorPattern);
-    expect(result.identifier.value).to.equal("person");
-    expect(result.args[0]).to.deep.equal(lit("Alice"));
-    expect(result.args[1]).to.deep.equal(lit(30));
-  });
-
-  it("should handle nested substitutions", () => {
-    const pattern = varPat("X");
-    const substs: Substitution = new Map<string, Pattern>([
-      ["X", new ListPattern([varPat("Y")])],
-      ["Y", lit("hello")],
-    ]);
-
-    const result = instantiate(pattern, substs) as ListPattern;
-    expect(result).to.be.instanceOf(ListPattern);
-    expect(result.elements[0]).to.deep.equal(lit("hello"));
-  });
-});
+import { expect } from "chai";
+import {
+  VariableTerm,
+  ConstantTerm,
+  ListTerm,
+  ConsTerm,
+  CompoundTerm,
+} from "../../src/interpreter/components/logic/LogicTerm.js";
+import {
+  Substitution,
+  LogicTerm,
+  YuNumber,
+  YuString,
+} from "../../src/interpreter/primitives/index.js";
+
+const number = (num: number) => new YuNumber(num);
+const string = (str: string) => new YuString(str);
+
+describe("Logic Substitution (instantiate)", () => {
+  it("should recursively substitute in ListTerm", () => {
+    const term = new ListTerm([
+      new VariableTerm(1, "X"),
+      new ConstantTerm(number(1)),
+      new VariableTerm(2, "Y"),
+    ]);
+    const substs: Substitution = new Map([
+      [1, new ConstantTerm(string("cat"))],
+      [2, new ConstantTerm(string("dog"))],
+    ]);
+
+    const result = term.instantiate(substs) as ListTerm;
+    expect(result).to.be.instanceOf(ListTerm);
+    expect((result.elements[0] as ConstantTerm).value).to.deep.equal(string("cat"));
+    expect((result.elements[1] as ConstantTerm).value).to.deep.equal(number(1));
+    expect((result.elements[2] as ConstantTerm).value).to.deep.equal(string("dog"));
+  });
+
+  it("should recursively substitute in ConsTerm", () => {
+    const term = new ConsTerm(
+      new VariableTerm(1, "X"),
+      new VariableTerm(2, "Y"),
+    );
+    const substs: Substitution = new Map<number, LogicTerm>([
+      [1, new ConstantTerm(number(1))],
+      [
+        2,
+        new ListTerm([
+          new ConstantTerm(number(2)),
+          new ConstantTerm(number(3)),
+        ]),
+      ],
+    ]);
+
+    const result = term.instantiate(substs) as ConsTerm;
+    expect(result).to.be.instanceOf(ConsTerm);
+    expect((result.head as ConstantTerm).value).to.deep.equal(number(1));
+    expect(result.tail).to.be.instanceOf(ListTerm);
+    expect((result.tail as ListTerm).elements).to.have.lengthOf(2);
+  });
+
+  it("should recursively substitute in CompoundTerm", () => {
+    const term = new CompoundTerm("person", [
+      new VariableTerm(1, "Name"),
+      new VariableTerm(2, "Age"),
+    ]);
+    const substs: Substitution = new Map([
+      [1, new ConstantTerm(string("Alice"))],
+      [2, new ConstantTerm(number(30))],
+    ]);
+
+    const result = term.instantiate(substs) as CompoundTerm;
+    expect(result).to.be.instanceOf(CompoundTerm);
+    expect(result.functor).to.equal("person");
+    expect((result.args[0] as ConstantTerm).value).to.deep.equal(string("Alice"));
+    expect((result.args[1] as ConstantTerm).value).to.deep.equal(number(30));
+  });
+
+  it("should handle nested substitutions", () => {
+    const term = new VariableTerm(1, "X");
+    const substs: Substitution = new Map<number, LogicTerm>([
+      [1, new ListTerm([new VariableTerm(2, "Y")])],
+      [2, new ConstantTerm(string("hello"))],
+    ]);
+
+    const result = term.instantiate(substs) as ListTerm;
+    expect(result).to.be.instanceOf(ListTerm);
+    const value = result.elements[0] as ConstantTerm;
+    expect(value.toPrimitive()).to.deep.equal(string("hello"));
+  });
+});