yukigo 0.2.3 → 0.3.2

package/tests/kernel/YukigoKernel.spec.ts

@@ -0,0 +1,112 @@
+import { expect } from "chai";
+import { YukigoKernel } from "../../src/interpreter/components/kernel/index.js";
+import {
+  BindCommand,
+  EvalCommand,
+  ExecutionCommand,
+  FailCommand,
+  StepCommand,
+} from "../../src/interpreter/components/kernel/commands.js";
+import {
+  YuNil,
+  YuNumber,
+  YuString,
+  YuValue,
+} from "../../src/interpreter/primitives/index.js";
+import { Evaluator } from "../../src/interpreter/components/evaluators/BaseEvaluator.js";
+
+describe("YukigoKernel", () => {
+  class MockEvaluator {
+    evaluate(node: any): ExecutionCommand {
+      return new StepCommand(node.mockValue);
+    }
+    getContext() {
+      return {
+        config: {
+          outputMode: "first",
+        },
+      };
+    }
+  }
+
+  let kernel: YukigoKernel;
+
+  beforeEach(() => {
+    kernel = new YukigoKernel(new MockEvaluator() as Evaluator);
+  });
+
+  it("must execute a StepCommand and end", () => {
+    const command = new StepCommand(new YuNumber(42));
+    const result = kernel.run(command) as YuNumber;
+
+    expect(result).to.be.instanceOf(YuNumber);
+    expect(result.value).to.equal(42);
+    expect(kernel.getLogicalTrace().length).to.eq(1);
+    expect(kernel.getLogicalTrace()[0].name).to.eq("STEP");
+  });
+
+  it("must chain multiple commands via BindCommand", () => {
+    // Chain: (Step 10) -> (add 5) -> (multiply 2)
+    const command = new BindCommand(
+      new StepCommand(new YuNumber(10)),
+      (a) =>
+        new BindCommand(
+          new StepCommand(new YuNumber(5)),
+          (b) =>
+            new BindCommand(
+              a.asNumeric?.plus(b) || new StepCommand(YuNil.getInstance()),
+              (sum) =>
+                sum.asNumeric?.multiply(new YuNumber(2)) ||
+                new StepCommand(YuNil.getInstance()),
+            ),
+        ),
+    );
+
+    const result = kernel.run(command) as YuNumber;
+
+    expect(result).to.be.instanceOf(YuNumber);
+    expect(result.value).to.equal(30);
+  });
+
+  it("must delegate EvalCommand to injected Evaluator", () => {
+    const dummyNode = { type: "Dummy", mockValue: new YuNumber(99) } as any;
+
+    const command = new BindCommand(
+      new EvalCommand(dummyNode),
+      (val) => (val as YuNumber).plus(new YuNumber(1)), // 99 + 1
+    );
+
+    const result = kernel.run(command) as YuNumber;
+
+    expect(result).to.be.instanceOf(YuNumber);
+    expect(result.value).to.equal(100);
+  });
+
+  it("must abort execution if FailCommand is raised", () => {
+    const command = new BindCommand(
+      new StepCommand(new YuNumber(1)),
+      () => new FailCommand(new Error("Fallo simulado")),
+    );
+
+    expect(() => kernel.run(command)).to.throw(
+      "[Yukigo VM Error] Fallo simulado",
+    );
+  });
+
+  it("must not overflow with deep recursive steps (50000 iterations)", () => {
+    const iteraciones = new YuNumber(50000);
+
+    const recursiveStep = (count: YuNumber): ExecutionCommand => {
+      if (count.equals(new YuNumber(0)))
+        return new StepCommand(new YuString("fin"));
+      return new BindCommand(new StepCommand(count), () =>
+        recursiveStep(count.minus(new YuNumber(1)) as any),
+      );
+    };
+
+    const result = kernel.run(recursiveStep(iteraciones)) as YuValue;
+
+    expect(result).to.be.instanceOf(YuString);
+    expect((result as YuString).value).to.equal("fin");
+  });
+});

package/tests/tester/Tester.spec.ts

@@ -1,152 +1,156 @@
-import { expect } from "chai";
-import {
-  Assert,
-  BooleanPrimitive,
-  Equality,
-  NumberPrimitive,
-  Sequence,
-  Test,
-  TestGroup,
-  StringPrimitive,
-  Variable,
-  SymbolPrimitive,
-  ArithmeticBinaryOperation,
-  Lambda,
-  Application,
-  VariablePattern,
-} from "yukigo-ast";
-import { Tester } from "../../src/tester/index.js";
-
-describe("Tester class", () => {
-  it("should run a simple passing test", () => {
-    const passingTest = new Test(
-      new StringPrimitive("Success"),
-      new Sequence([
-        new Assert(
-          new BooleanPrimitive(false),
-          new Equality(new NumberPrimitive(1), new NumberPrimitive(1)),
-        ),
-      ]),
-    );
-
-    const tester = new Tester([passingTest]);
-    const results = tester.test([passingTest]);
-
-    expect(results).to.have.lengthOf(1);
-    expect(results[0].name).to.equal("Success");
-    expect(results[0].status).to.equal("passed");
-  });
-
-  it("should report a failing test with a message", () => {
-    const failingTest = new Test(
-      new StringPrimitive("Failure"),
-      new Sequence([
-        new Assert(
-          new BooleanPrimitive(false),
-          new Equality(new NumberPrimitive(1), new NumberPrimitive(2)),
-        ),
-      ]),
-    );
-
-    const tester = new Tester([failingTest]);
-    const results = tester.test([failingTest]);
-
-    expect(results).to.have.lengthOf(1);
-    expect(results[0].status).to.equal("failed");
-    expect(results[0].message).to.contain("Expected 1, but got 2");
-  });
-
-  it("should run tests inside a TestGroup independently", () => {
-    const passingTest = new Test(
-      new StringPrimitive("Pass"),
-      new Sequence([
-        new Assert(
-          new BooleanPrimitive(false),
-          new Equality(new NumberPrimitive(10), new NumberPrimitive(10)),
-        ),
-      ]),
-    );
-
-    const failingTest = new Test(
-      new StringPrimitive("Fail"),
-      new Sequence([
-        new Assert(
-          new BooleanPrimitive(false),
-          new Equality(new NumberPrimitive(1), new NumberPrimitive(0)),
-        ),
-      ]),
-    );
-
-    const group = new TestGroup(
-      new StringPrimitive("My Group"),
-      new Sequence([passingTest, failingTest]),
-    );
-
-    const tester = new Tester([group]);
-    const results = tester.test([group]);
-
-    expect(results).to.have.lengthOf(1);
-    const groupReport = results[0];
-    expect(groupReport.name).to.equal("My Group");
-    expect(groupReport.status).to.equal("failed");
-    expect(groupReport.children).to.have.lengthOf(2);
-    expect(groupReport.children![0].status).to.equal("passed");
-    expect(groupReport.children![1].status).to.equal("failed");
-  });
-
-  it("should handle setup code inside a TestGroup", () => {
-    // var x = 5
-    const setup = new Variable(
-      new SymbolPrimitive("x"),
-      new NumberPrimitive(5),
-    );
-
-    // test "Check X" { assert x == 5 }
-    const checkX = new Test(
-      new StringPrimitive("Check X"),
-      new Sequence([
-        new Assert(
-          new BooleanPrimitive(false),
-          new Equality(new SymbolPrimitive("x"), new NumberPrimitive(5)),
-        ),
-      ]),
-    );
-
-    const group = new TestGroup(
-      new StringPrimitive("Setup Group"),
-      new Sequence([setup, checkX]),
-    );
-
-    const tester = new Tester([group]);
-    const results = tester.test([group]);
-
-    expect(results[0].children).to.have.lengthOf(1);
-    expect(results[0].children![0].status).to.equal("passed");
-  });
-
-  it("should report errors that are not FailedAssert", () => {
-    // test "Error" { 1 + "a" }
-    const errorTest = new Test(
-      new StringPrimitive("Error"),
-      new Sequence([
-        new Application(
-          new Lambda(
-            [new VariablePattern(new SymbolPrimitive("b"))],
-            new ArithmeticBinaryOperation(
-              "Plus",
-              new SymbolPrimitive("b"),
-              new StringPrimitive("a"),
-            ),
-          ),
-          new NumberPrimitive(1),
-        ),
-      ]),
-    );
-
-    const tester = new Tester([errorTest]);
-    const results = tester.test([errorTest]);
-
-    expect(results[0].status).to.equal("error");
-    expect(results[0].message).to.contain("Type mismatch");
-  });
-});
+import { expect } from "chai";
+import {
+  Assert,
+  BooleanPrimitive,
+  Equality,
+  NumberPrimitive,
+  Sequence,
+  Test,
+  TestGroup,
+  StringPrimitive,
+  Variable,
+  SymbolPrimitive,
+  ArithmeticBinaryOperation,
+  Lambda,
+  Call,
+  Application,
+  VariablePattern,
+  Function,
+  Equation,
+  UnguardedBody,
+  Return,
+} from "yukigo-ast";
+import { Tester } from "../../src/tester/index.js";
+
+describe("Tester class", () => {
+  it("should run a simple passing test", () => {
+    const passingTest = new Test(
+      new StringPrimitive("Success"),
+      new Sequence([
+        new Assert(
+          new BooleanPrimitive(false),
+          new Equality(new NumberPrimitive(1), new NumberPrimitive(1)),
+        ),
+      ]),
+    );
+
+    const tester = new Tester([passingTest]);
+    const results = tester.test([passingTest]);
+
+    expect(results).to.have.lengthOf(1);
+    expect(results[0].name).to.equal("Success");
+    expect(results[0].status).to.equal("passed");
+  });
+
+  it("should report a failing test with a message", () => {
+    const failingTest = new Test(
+      new StringPrimitive("Failure"),
+      new Sequence([
+        new Assert(
+          new BooleanPrimitive(false),
+          new Equality(new NumberPrimitive(1), new NumberPrimitive(2)),
+        ),
+      ]),
+    );
+
+    const tester = new Tester([failingTest]);
+    const results = tester.test([failingTest]);
+
+    expect(results).to.have.lengthOf(1);
+    expect(results[0].status).to.equal("failed");
+    expect(results[0].message).to.contain("Expected 1, but got 2");
+  });
+
+  it("should run tests inside a TestGroup independently", () => {
+    const passingTest = new Test(
+      new StringPrimitive("Pass"),
+      new Sequence([
+        new Assert(
+          new BooleanPrimitive(false),
+          new Equality(new NumberPrimitive(10), new NumberPrimitive(10)),
+        ),
+      ]),
+    );
+
+    const failingTest = new Test(
+      new StringPrimitive("Fail"),
+      new Sequence([
+        new Assert(
+          new BooleanPrimitive(false),
+          new Equality(new NumberPrimitive(1), new NumberPrimitive(0)),
+        ),
+      ]),
+    );
+
+    const group = new TestGroup(
+      new StringPrimitive("My Group"),
+      new Sequence([passingTest, failingTest]),
+    );
+
+    const tester = new Tester([group]);
+    const results = tester.test([group]);
+
+    expect(results).to.have.lengthOf(1);
+    const groupReport = results[0];
+    expect(groupReport.name).to.equal("My Group");
+    expect(groupReport.status).to.equal("failed");
+    expect(groupReport.children).to.have.lengthOf(2);
+    expect(groupReport.children![0].status).to.equal("passed");
+    expect(groupReport.children![1].status).to.equal("failed");
+  });
+
+  it("should handle setup code inside a TestGroup", () => {
+    // var x = 5
+    const setup = new Variable(
+      new SymbolPrimitive("x"),
+      new NumberPrimitive(5),
+    );
+
+    // test "Check X" { assert x == 5 }
+    const checkX = new Test(
+      new StringPrimitive("Check X"),
+      new Sequence([
+        new Assert(
+          new BooleanPrimitive(false),
+          new Equality(new SymbolPrimitive("x"), new NumberPrimitive(5)),
+        ),
+      ]),
+    );
+
+    const group = new TestGroup(
+      new StringPrimitive("Setup Group"),
+      new Sequence([setup, checkX]),
+    );
+
+    const tester = new Tester([group]);
+    const results = tester.test([group]);
+
+    expect(results[0].children).to.have.lengthOf(1);
+    expect(results[0].children![0].status).to.equal("passed");
+  });
+
+  it("should report errors that are not FailedAssert", () => {
+    // test "Error" { 1 * "a" }
+    const errorTest = new Test(
+      new StringPrimitive("Error"),
+      new Sequence([
+        new Application(
+          new Lambda(
+            [new VariablePattern(new SymbolPrimitive("b"))],
+            new ArithmeticBinaryOperation(
+              "Multiply",
+              new SymbolPrimitive("b"),
+              new StringPrimitive("a"),
+            ),
+          ),
+          new NumberPrimitive(1),
+        ),
+      ]),
+    );
+
+    const tester = new Tester([errorTest]);
+    const results = tester.test([errorTest]);
+    expect(results[0].status).to.equal("error");
+    expect(results[0].message).to.contain("Type mismatch");
+  });
+});

package/tsconfig.build.json

@@ -1,15 +1,16 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": false
-  },
-  "exclude": [
-    "dist/**/*",
-    "tests/**/*"
-  ],
-  "references": [
-    {
-      "path": "../yukigo-ast"
-    }
-  ],
-}
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "rootDir": "src"
+  },
+  "exclude": [
+    "dist/**/*",
+    "tests/**/*"
+  ],
+  "references": [
+    {
+      "path": "../yukigo-ast"
+    }
+  ],
+}

package/tsconfig.json

@@ -1,25 +1,27 @@
-{
-  "compilerOptions": {
-    "target": "es2024",
-    "experimentalDecorators": true,
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
-    "lib": ["es2024", "dom"],
-    "outDir": "./dist",
-    "declaration": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true,
-    "noEmit": true
-  },
-  "include": ["src"],
-  "exclude": [
-    "dist/**/*"
-  ],
-  "references": [
-    {
-      "path": "../yukigo-ast"
-    }
-  ]
-}
+{
+  "compilerOptions": {
+    "target": "es2025",
+    "experimentalDecorators": true,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "lib": ["es2025", "dom"],
+    "outDir": "./dist",
+    "rootDir": "./",
+    "declaration": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["node", "mocha", "chai"]
+  },
+  "include": ["src/**/*", "tests/**/*"],
+  "exclude": [
+    "dist/**/*"
+  ],
+  "references": [
+    {
+      "path": "../yukigo-ast"
+    }
+  ]
+}

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

@@ -1,70 +0,0 @@
-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";
-import { RuntimeContext } from "./RuntimeContext.js";
-export declare class InterpreterVisitor implements Visitor<CPSThunk<PrimitiveValue>>, ExpressionEvaluator {
-    private context;
-    private frames;
-    constructor(context: RuntimeContext, frames?: ErrorFrame[]);
-    evaluate<R = PrimitiveValue>(node: ASTNode, cont: Continuation<PrimitiveValue, R>): Thunk<R>;
-    visitSequence(node: Sequence): CPSThunk<PrimitiveValue>;
-    visitAssert(node: Assert): CPSThunk<PrimitiveValue>;
-    visitTest(node: Test): CPSThunk<PrimitiveValue>;
-    visitTestGroup(node: TestGroup): CPSThunk<PrimitiveValue>;
-    visitNumberPrimitive(node: NumberPrimitive): CPSThunk<PrimitiveValue>;
-    visitBooleanPrimitive(node: BooleanPrimitive): CPSThunk<PrimitiveValue>;
-    visitStringPrimitive(node: StringPrimitive): CPSThunk<PrimitiveValue>;
-    visitListPrimitive(node: ListPrimitive): CPSThunk<PrimitiveValue>;
-    visitNilPrimitive(node: NilPrimitive): CPSThunk<PrimitiveValue>;
-    visitCharPrimitive(node: CharPrimitive): CPSThunk<PrimitiveValue>;
-    visitSymbolPrimitive(node: SymbolPrimitive): CPSThunk<PrimitiveValue>;
-    visitVariable(node: Variable): CPSThunk<PrimitiveValue>;
-    visitAssignment(node: Assignment): CPSThunk<PrimitiveValue>;
-    visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): CPSThunk<PrimitiveValue>;
-    visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): CPSThunk<PrimitiveValue>;
-    visitListUnaryOperation(node: ListUnaryOperation): CPSThunk<PrimitiveValue>;
-    visitListBinaryOperation(node: ListBinaryOperation): CPSThunk<PrimitiveValue>;
-    visitComparisonOperation(node: ComparisonOperation): CPSThunk<PrimitiveValue>;
-    visitLogicalBinaryOperation(node: LogicalBinaryOperation): CPSThunk<PrimitiveValue>;
-    visitLogicalUnaryOperation(node: LogicalUnaryOperation): CPSThunk<PrimitiveValue>;
-    visitBitwiseBinaryOperation(node: BitwiseBinaryOperation): CPSThunk<PrimitiveValue>;
-    visitBitwiseUnaryOperation(node: BitwiseUnaryOperation): CPSThunk<PrimitiveValue>;
-    visitStringOperation(node: StringOperation): CPSThunk<PrimitiveValue>;
-    visitUnifyOperation(node: UnifyOperation): CPSThunk<PrimitiveValue>;
-    visitAssignOperation(node: AssignOperation): CPSThunk<PrimitiveValue>;
-    visitTupleExpr(node: TupleExpression): CPSThunk<PrimitiveValue>;
-    visitFieldExpression(node: FieldExpression): CPSThunk<PrimitiveValue>;
-    visitDataExpr(node: DataExpression): CPSThunk<PrimitiveValue>;
-    visitConsExpr(node: ConsExpression): CPSThunk<PrimitiveValue>;
-    visitLetInExpr(node: LetInExpression): CPSThunk<PrimitiveValue>;
-    visitIf(node: If): CPSThunk<PrimitiveValue>;
-    visitCall(node: Call): CPSThunk<PrimitiveValue>;
-    visitOtherwise(node: Otherwise): CPSThunk<PrimitiveValue>;
-    visitCompositionExpression(node: CompositionExpression): CPSThunk<PrimitiveValue>;
-    visitLambda(node: Lambda): CPSThunk<PrimitiveValue>;
-    visitApplication(node: Application): CPSThunk<PrimitiveValue>;
-    visitQuery(node: Query): CPSThunk<PrimitiveValue>;
-    visitExist(node: Exist): CPSThunk<PrimitiveValue>;
-    visitNot(node: Not): CPSThunk<PrimitiveValue>;
-    visitFindall(node: Findall): CPSThunk<PrimitiveValue>;
-    visitForall(node: Forall): CPSThunk<PrimitiveValue>;
-    visitGoal(node: Goal): CPSThunk<PrimitiveValue>;
-    private bindLogicResults;
-    visitLogicConstraint(node: LogicConstraint): CPSThunk<PrimitiveValue>;
-    visitSuper(node: Super): CPSThunk<PrimitiveValue>;
-    visitSend(node: Send): CPSThunk<PrimitiveValue>;
-    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>;
-    visit(node: Expression): CPSThunk<PrimitiveValue>;
-    realizeList<R = PrimitiveValue[]>(val: PrimitiveValue, k: Continuation<PrimitiveValue[], R>): Thunk<R>;
-    private processBinary;
-    private processUnary;
-    private getLogicEngine;
-    static evaluateLiteral(node: ASTNode): PrimitiveValue;
-}