yukigo 0.1.0

package/tests/interpreter/EnvBuilder.spec.ts

@@ -0,0 +1,178 @@
+import { expect } from 'chai';
+import {
+  Function as AstFunction,
+  Fact,
+  Rule,
+  SymbolPrimitive,
+  Equation,
+} from 'yukigo-ast';
+import { EnvBuilderVisitor } from '../../src/interpreter/components/EnvBuilder.js';
+
+const id = (val: string) => ({ value: val } as SymbolPrimitive);
+
+const makeEq = (arity: number): Equation => ({
+  patterns: new Array(arity).fill({ type: 'MockPattern' }), // Relleno dummy
+  body: { type: 'MockBody' } as any
+} as any);
+
+const makeFunc = (name: string, arity: number, eqCount: number = 1): AstFunction => ({
+  type: 'Function',
+  identifier: id(name),
+  equations: new Array(eqCount).fill(null).map(() => makeEq(arity)),
+  accept: (v: any) => v.visitFunction(makeFunc(name, arity, eqCount))
+} as any);
+
+const makeFact = (name: string): Fact => ({
+  type: 'Fact',
+  identifier: id(name),
+  patterns: [],
+  accept: (v: any) => v.visitFact(makeFact(name))
+} as any);
+
+const makeRule = (name: string): Rule => ({
+  type: 'Rule',
+  identifier: id(name),
+  patterns: [],
+  expressions: [],
+  accept: (v: any) => v.visitRule(makeRule(name))
+} as any);
+
+describe('EnvBuilderVisitor', () => {
+  let visitor: EnvBuilderVisitor;
+  let env: Map<string, any>;
+
+  beforeEach(() => {
+    const initialStack = [new Map<string, any>()];
+    visitor = new EnvBuilderVisitor(initialStack);
+    env = initialStack[0];
+  });
+
+  describe('Function Declarations', () => {
+    it('should register a valid function', () => {
+      const funcNode = makeFunc('myFunc', 1);
+      
+      visitor.visitFunction(funcNode);
+
+      expect(env.has('myFunc')).to.be.true;
+      const entry = env.get('myFunc');
+      
+      expect(entry).to.have.property('identifier', 'myFunc');
+      expect(entry).to.have.property('arity', 1);
+      expect(entry.equations).to.have.lengthOf(1);
+    });
+
+    it('should register a function with multiple equations', () => {
+      const funcNode = makeFunc('fib', 1, 2);
+      
+      visitor.visitFunction(funcNode);
+      
+      const entry = env.get('fib');
+      expect(entry.equations).to.have.lengthOf(2);
+    });
+
+    it('should throw error if function has no equations', () => {
+      const funcNode = makeFunc('empty', 0, 0);
+      
+      expect(() => visitor.visitFunction(funcNode))
+        .to.throw(/has no equations/);
+    });
+
+    it('should throw error if equations have different arity', () => {
+      const funcNode = makeFunc('badFunc', 1);
+      funcNode.equations.push(makeEq(2));
+
+      expect(() => visitor.visitFunction(funcNode))
+        .to.throw(/must have the same arity/);
+    });
+  });
+
+  describe('Logic Programming (Facts)', () => {
+    it('should register a new Fact', () => {
+      const factNode = makeFact('parent');
+      
+      visitor.visitFact(factNode);
+
+      expect(env.has('parent')).to.be.true;
+      const entry = env.get('parent');
+      expect(entry).to.have.property('kind', 'Fact');
+      expect(entry.equations).to.have.lengthOf(1);
+      expect(entry.equations[0]).to.equal(factNode);
+    });
+
+    it('should append to existing Fact if identifier exists', () => {
+      const fact1 = makeFact('parent');
+      const fact2 = makeFact('parent');
+
+      visitor.visitFact(fact1);
+      visitor.visitFact(fact2);
+
+      const entry = env.get('parent');
+      expect(entry.kind).to.equal('Fact');
+      expect(entry.equations).to.have.lengthOf(2);
+      expect(entry.equations[0]).to.equal(fact1);
+      expect(entry.equations[1]).to.equal(fact2);
+    });
+
+    it('should overwrite existing entry if it is not a Fact', () => {
+      env.set('test', { kind: 'SomethingElse', equations: [] });
+
+      const fact = makeFact('test');
+      visitor.visitFact(fact);
+
+      const entry = env.get('test');
+      expect(entry.kind).to.equal('Fact');
+      expect(entry.equations).to.have.lengthOf(1);
+    });
+  });
+
+  describe('Logic Programming (Rules)', () => {
+    it('should register a new Rule', () => {
+      const ruleNode = makeRule('grandparent');
+      
+      visitor.visitRule(ruleNode);
+
+      expect(env.has('grandparent')).to.be.true;
+      const entry = env.get('grandparent');
+      expect(entry).to.have.property('kind', 'Rule');
+      expect(entry.equations).to.have.lengthOf(1);
+    });
+
+    it('should append to existing Rule group', () => {
+      const rule1 = makeRule('ancestor');
+      const rule2 = makeRule('ancestor');
+
+      visitor.visitRule(rule1);
+      visitor.visitRule(rule2);
+
+      const entry = env.get('ancestor');
+      expect(entry.kind).to.equal('Rule');
+      expect(entry.equations).to.have.lengthOf(2);
+    });
+  });
+
+  describe('Build Method (Integration)', () => {
+    it('should traverse the AST and build the complete environment', () => {
+      const nodes = [
+        makeFunc('add', 2),
+        makeFact('is_human'),
+        makeRule('is_mortal')
+      ];
+
+      const mockAST = {
+        [Symbol.iterator]: function* () { yield* nodes; }
+      } as any;
+
+      // mock of the accept method
+      nodes[0].accept = (v: any) => v.visitFunction(nodes[0]);
+      nodes[1].accept = (v: any) => v.visitFact(nodes[1]);
+      nodes[2].accept = (v: any) => v.visitRule(nodes[2]);
+
+      const resultingStack = visitor.build(mockAST);
+      const resultingEnv = resultingStack[0];
+
+      expect(resultingEnv.has('add')).to.be.true;
+      expect(resultingEnv.has('is_human')).to.be.true;
+      expect(resultingEnv.has('is_mortal')).to.be.true;
+    });
+  });
+});

package/tests/interpreter/FunctionRuntime.spec.ts

@@ -0,0 +1,234 @@
+import { expect } from "chai";
+import {
+  EquationRuntime,
+  UnguardedBody,
+  Sequence,
+  Return,
+  SymbolPrimitive,
+  NumberPrimitive,
+  LiteralPattern,
+  VariablePattern,
+  GuardedBody,
+} from "yukigo-ast";
+import { FunctionRuntime } from "../../src/interpreter/components/FunctionRuntime.js";
+
+const s = (val: string) => new SymbolPrimitive(val);
+const n = (val: number) => new NumberPrimitive(val);
+const litPat = (val: number | string) =>
+  new LiteralPattern(typeof val === "number" ? n(val) : s(val));
+const varPat = (name: string) => new VariablePattern(s(name));
+const valExpr = (val: any) => ({ type: "Value", value: val } as any);
+const varExpr = (name: string) => ({ type: "Variable", value: name } as any);
+const seq = (stmts: any[]) => new Sequence(stmts);
+const unguarded = (stmts: any[]) => new UnguardedBody(seq(stmts));
+const guarded = (guards: { cond: any; body: any }[]): GuardedBody[] => {
+  return guards.map((g) => new GuardedBody(g.cond, valExpr(g.body)));
+};
+
+class MockEvaluator {
+  constructor(public env: any[]) {}
+
+  evaluate(node: any): any {
+    if (node.type === "Value") return node.value;
+    if (node.type === "Variable") {
+      const val = this.env[0].get(node.value);
+      return val !== undefined ? val : `Error: ${node.value} not found`;
+    }
+    return node;
+  }
+}
+
+describe("FunctionRuntime", () => {
+  let globalEnv: any[];
+  let evaluatorFactory: any;
+
+  beforeEach(() => {
+    globalEnv = [new Map()];
+    evaluatorFactory = (env: any[]) => new MockEvaluator(env);
+  });
+
+  describe("Pattern Matching & Dispatch", () => {
+    it("should match arguments to literal patterns", () => {
+      const eq1: EquationRuntime = {
+        patterns: [litPat(10)],
+        body: unguarded([valExpr("ten")]),
+      };
+      const eq2: EquationRuntime = {
+        patterns: [litPat(20)],
+        body: unguarded([valExpr("twenty")]),
+      };
+
+      const result = FunctionRuntime.apply(
+        "f",
+        [eq1, eq2],
+        [20],
+        globalEnv,
+        evaluatorFactory
+      );
+
+      expect(result).to.equal("twenty");
+    });
+
+    it("should throw error if no pattern matches (Non-exhaustive)", () => {
+      const eq1: EquationRuntime = {
+        patterns: [litPat(10)],
+        body: unguarded([valExpr("ten")]),
+      };
+
+      expect(() => {
+        FunctionRuntime.apply("f", [eq1], [99], globalEnv, evaluatorFactory);
+      }).to.throw(/Non-exhaustive patterns/);
+    });
+
+    it("should skip equations with wrong arity (argument count)", () => {
+      const eq1: EquationRuntime = {
+        patterns: [varPat("X")],
+        body: unguarded([valExpr("one arg")]),
+      };
+
+      expect(() => {
+        FunctionRuntime.apply("f", [eq1], [1, 2], globalEnv, evaluatorFactory);
+      }).to.throw(/Non-exhaustive patterns/);
+    });
+  });
+
+  describe("Scope & Bindings", () => {
+    it("should bind variables to a new local scope", () => {
+      const eq1: EquationRuntime = {
+        patterns: [varPat("X")],
+        body: unguarded([varExpr("X")]),
+      };
+
+      const result = FunctionRuntime.apply(
+        "identity",
+        [eq1],
+        [500],
+        globalEnv,
+        evaluatorFactory
+      );
+
+      expect(result).to.equal(500);
+    });
+
+    it("should prioritize local scope over global scope", () => {
+      globalEnv[0].set("X", 1);
+
+      const eq1: EquationRuntime = {
+        patterns: [varPat("X")],
+        body: unguarded([varExpr("X")]),
+      };
+
+      const result = FunctionRuntime.apply(
+        "shadow",
+        [eq1],
+        [999],
+        globalEnv,
+        evaluatorFactory
+      );
+      expect(result).to.equal(999);
+    });
+  });
+
+  describe("Guarded Bodies", () => {
+    const guardedEvaluatorFactory = (env: any[]) => ({
+      evaluate: (node: any) => {
+        if (node.type === "Condition") return node.value;
+        if (node.type === "Value") return node.value;
+        return null;
+      },
+    });
+
+    it("should execute the body of the first true guard", () => {
+      const guards = [
+        { cond: { type: "Condition", value: false }, body: 1 },
+        { cond: { type: "Condition", value: true }, body: 2 },
+      ];
+
+      const eq: EquationRuntime = {
+        patterns: [varPat("_")],
+        body: guarded(guards),
+      };
+
+      const result = FunctionRuntime.apply(
+        "guards",
+        [eq],
+        [0],
+        globalEnv,
+        guardedEvaluatorFactory as any
+      );
+      expect(result).to.equal(2);
+    });
+
+    it("should fall through to next equation if no guard matches", () => {
+      const eq1: EquationRuntime = {
+        patterns: [varPat("_")],
+        body: guarded([{ cond: { type: "Condition", value: false }, body: 1 }]),
+      };
+
+      const eq2: EquationRuntime = {
+        patterns: [varPat("_")],
+        body: unguarded([valExpr(2)]),
+      };
+
+      const result = FunctionRuntime.apply(
+        "fallback",
+        [eq1, eq2],
+        [0],
+        globalEnv,
+        guardedEvaluatorFactory as any
+      );
+      expect(result).to.equal(2);
+    });
+  });
+
+  describe("Imperative Sequences & Returns", () => {
+    it("should return the value of the last statement implicitly", () => {
+      const eq: EquationRuntime = {
+        patterns: [],
+        body: unguarded([valExpr(10), valExpr(20), valExpr(30)]),
+      };
+
+      const result = FunctionRuntime.apply(
+        "seq",
+        [eq],
+        [],
+        globalEnv,
+        evaluatorFactory
+      );
+      expect(result).to.equal(30);
+    });
+
+    it("should return early with Return statement", () => {
+      const retStmt = new Return(valExpr(99));
+
+      const eq: EquationRuntime = {
+        patterns: [],
+        body: unguarded([valExpr(10), retStmt, valExpr(30)]),
+      };
+
+      const result = FunctionRuntime.apply(
+        "earlyRet",
+        [eq],
+        [],
+        globalEnv,
+        evaluatorFactory
+      );
+      expect(result).to.equal(99);
+    });
+
+    it("should return undefined for empty sequence", () => {
+      const eq: EquationRuntime = {
+        patterns: [],
+        body: unguarded([]),
+      };
+      const result = FunctionRuntime.apply(
+        "empty",
+        [eq],
+        [],
+        globalEnv,
+        evaluatorFactory
+      );
+      expect(result).to.be.undefined;
+    });
+  });
+});

package/tests/interpreter/LazyRuntime.spec.ts

@@ -0,0 +1,190 @@
+import { expect } from "chai";
+import { LazyRuntime } from "../../src/interpreter/components/LazyRuntime.js";
+import {
+  RangeExpression,
+  ConsExpression,
+  LazyList,
+  NumberPrimitive,
+} from "yukigo-ast";
+import { createStream } from "../../src/interpreter/utils.js";
+
+class MockEvaluator {
+  evaluate(node: any): any {
+    if (node && typeof node === "object" && "value" in node) {
+      return node.value;
+    }
+    return node;
+  }
+}
+
+const num = (value: number) => new NumberPrimitive(value);
+
+const range = (start: number, end?: number, step?: number): RangeExpression =>
+  new RangeExpression(
+    num(start),
+    end ? num(end) : undefined,
+    step ? num(step) : undefined
+  );
+
+// Helper para crear nodos Cons
+const cons = (headVal: any, tailVal: any): ConsExpression =>
+  new ConsExpression(headVal, tailVal);
+
+describe("LazyRuntime", () => {
+  let evaluator: any;
+
+  beforeEach(() => {
+    evaluator = new MockEvaluator();
+  });
+
+  describe("realizeList", () => {
+    it("should return the array as-is if input is already an array", () => {
+      const input = [1, 2, 3];
+      const result = LazyRuntime.realizeList(input);
+      expect(result).to.equal(input);
+      expect(result).to.deep.equal([1, 2, 3]);
+    });
+
+    it("should consume a LazyList into an array", () => {
+      const lazyList: LazyList = createStream(function* () {
+        yield 10;
+        yield 20;
+      });
+
+      const result = LazyRuntime.realizeList(lazyList);
+      expect(result).to.deep.equal([10, 20]);
+    });
+
+    it("should throw if value is not a list or lazy list", () => {
+      expect(() => LazyRuntime.realizeList(123 as any)).to.throw(
+        /Expected List or LazyList/
+      );
+    });
+  });
+
+  describe("evaluateRange", () => {
+    describe("Finite Ranges", () => {
+      it("should create a simple range [1..5]", () => {
+        const node = range(1, 5);
+        const result = LazyRuntime.evaluateRange(node, evaluator, {
+          lazyLoading: false,
+        });
+        expect(result).to.deep.equal([1, 2, 3, 4, 5]);
+      });
+
+      it("should handle custom steps [0, 2 .. 10]", () => {
+        const node = range(0, 10, 2);
+        const result = LazyRuntime.evaluateRange(node, evaluator, {
+          lazyLoading: false,
+        });
+        expect(result).to.deep.equal([0, 2, 4, 6, 8, 10]);
+      });
+
+      it("should handle negative steps [5, 4 .. 1]", () => {
+        const node = range(5, 1, 4);
+        const result = LazyRuntime.evaluateRange(node, evaluator, {
+          lazyLoading: false,
+        });
+        expect(result).to.deep.equal([5, 4, 3, 2, 1]);
+      });
+
+      it("should throw if step is zero", () => {
+        const node = range(5, 10, 5);
+        expect(() => LazyRuntime.evaluateRange(node, evaluator, {})).to.throw(
+          /Range step cannot be zero/
+        );
+      });
+    });
+
+    describe("Infinite Ranges", () => {
+      it("should return a LazyList object", () => {
+        const node = range(1);
+        const result = LazyRuntime.evaluateRange(node, evaluator, {
+          lazyLoading: true,
+        });
+
+        expect(result).to.have.property("type", "LazyList");
+        expect(result).to.have.property("generator");
+      });
+
+      it("should generate values on demand [1..]", () => {
+        const node = range(1);
+        const result = LazyRuntime.evaluateRange(node, evaluator, {
+          lazyLoading: true,
+        }) as LazyList;
+        const gen = result.generator();
+        expect(gen.next().value).to.equal(1);
+        expect(gen.next().value).to.equal(2);
+        expect(gen.next().value).to.equal(3);
+      });
+
+      it("should generate values with step on demand [0, 5 ..]", () => {
+        const node = range(0, undefined, 5);
+        const result = LazyRuntime.evaluateRange(node, evaluator, {
+          lazyLoading: true,
+        }) as LazyList;
+
+        const gen = result.generator();
+        expect(gen.next().value).to.equal(0);
+        expect(gen.next().value).to.equal(5);
+        expect(gen.next().value).to.equal(10);
+      });
+    });
+  });
+
+  describe("evaluateCons", () => {
+    describe("Eager Mode (lazy: false)", () => {
+      it("should construct an array if tail is an array", () => {
+        const node = cons(1, [2, 3]);
+        const result = LazyRuntime.evaluateCons(node, evaluator, false);
+        expect(result).to.deep.equal([1, 2, 3]);
+      });
+
+      it("should throw if tail is not an array", () => {
+        const lazyListMock = { type: "LazyList" };
+        const node = cons(1, lazyListMock);
+
+        expect(() => LazyRuntime.evaluateCons(node, evaluator, false)).to.throw(
+          /Expected Array in eager Cons/
+        );
+      });
+    });
+
+    describe("Lazy Mode (lazy: true)", () => {
+      it("should return an array if tail is an array (hybrid)", () => {
+        const node = cons(1, [2, 3]);
+        const result = LazyRuntime.evaluateCons(node, evaluator, true);
+        expect(result).to.deep.equal([1, 2, 3]);
+      });
+
+      it("should return a new LazyList if tail is a LazyList", () => {
+        const tailLazy: LazyList = createStream(function* () {
+          yield 2;
+          yield 3;
+        });
+
+        const node = cons(1, tailLazy);
+        const result = LazyRuntime.evaluateCons(
+          node,
+          evaluator,
+          true
+        ) as LazyList;
+
+        expect(result.type).to.equal("LazyList");
+
+        const gen = result.generator();
+        expect(gen.next().value).to.equal(1);
+        expect(gen.next().value).to.equal(2);
+        expect(gen.next().value).to.equal(3);
+        expect(gen.next().done).to.be.true;
+      });
+
+      it("should throw if tail is invalid", () => {
+        const node = cons(1, "invalid string");
+        expect(() => LazyRuntime.evaluateCons(node, evaluator, true)).to.throw(
+          /Invalid tail type/
+        );
+      });
+    });
+  });
+});