@graffiticode/parser 1.3.1 → 1.4.1

package/.claude/settings.local.json

@@ -6,7 +6,9 @@
       "Bash(npm test:*)",
       "Bash(npm publish:*)",
       "Bash(grep:*)",
-      "Bash(npm install:*)"
+      "Bash(npm install:*)",
+      "Bash(NODE_OPTIONS=--experimental-vm-modules node -e \"\nimport { parser } from './src/parser.js';\nimport { unparse } from './src/unparse.js';\nimport { lexicon as basisLexicon } from '@graffiticode/basis';\n\nconst src = 'case x of 1: \\\\\"one\\\\\" 2: \\\\\"two\\\\\" end..';\nconsole.log\\('Input:', src\\);\nconst ast = await parser.parse\\(0, src, basisLexicon\\);\nconsole.log\\('AST:', JSON.stringify\\(ast, null, 2\\)\\);\nconst result = unparse\\(ast, basisLexicon\\);\nconsole.log\\('Unparsed:', result\\);\n\")",
+      "Bash(NODE_OPTIONS=--experimental-vm-modules node -e \"\nimport { parser } from './src/parser.js';\nimport { unparse } from './src/unparse.js';\nimport { lexicon as basisLexicon } from '@graffiticode/basis';\n\n// Test nested case-of\nconst src1 = 'case x of 1: case y of 3: \\\\\"a\\\\\" 4: \\\\\"b\\\\\" end 2: \\\\\"two\\\\\" end..';\nconsole.log\\('Input:', src1\\);\ntry {\n  const ast1 = await parser.parse\\(0, src1, basisLexicon\\);\n  console.log\\('Unparsed:', unparse\\(ast1, basisLexicon\\)\\);\n} catch\\(e\\) { console.log\\('Error:', e.message\\); }\n\nconsole.log\\('---'\\);\n\n// Test with expression as case target\nconst src2 = 'case add 1 2 of 3: \\\\\"yes\\\\\" 4: \\\\\"no\\\\\" end..';\nconsole.log\\('Input:', src2\\);\ntry {\n  const ast2 = await parser.parse\\(0, src2, basisLexicon\\);\n  console.log\\('AST:', JSON.stringify\\(ast2, null, 2\\)\\);\n  console.log\\('Unparsed:', unparse\\(ast2, basisLexicon\\)\\);\n} catch\\(e\\) { console.log\\('Error:', e.message\\); }\n\nconsole.log\\('---'\\);\n\n// Test with identifier patterns\nconst src3 = 'case x of y: y end..';\nconsole.log\\('Input:', src3\\);\ntry {\n  const ast3 = await parser.parse\\(0, src3, basisLexicon\\);\n  console.log\\('AST:', JSON.stringify\\(ast3, null, 2\\)\\);\n  console.log\\('Unparsed:', unparse\\(ast3, basisLexicon\\)\\);\n} catch\\(e\\) { console.log\\('Error:', e.message\\); }\n\nconsole.log\\('---'\\);\n\n// Test case-of inside a let or other expression\nconst src4 = 'let x = 5 in case x of 5: \\\\\"five\\\\\" end..';\nconsole.log\\('Input:', src4\\);\ntry {\n  const ast4 = await parser.parse\\(0, src4, basisLexicon\\);\n  console.log\\('Unparsed:', unparse\\(ast4, basisLexicon\\)\\);\n} catch\\(e\\) { console.log\\('Error:', e.message\\); }\n\nconsole.log\\('---'\\);\n\n// Test case-of as argument to a function\nconst src5 = 'add \\(case x of 1: 10 2: 20 end\\) 5..';\nconsole.log\\('Input:', src5\\);\ntry {\n  const ast5 = await parser.parse\\(0, src5, basisLexicon\\);\n  console.log\\('Unparsed:', unparse\\(ast5, basisLexicon\\)\\);\n} catch\\(e\\) { console.log\\('Error:', e.message\\); }\n\")"
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiticode/parser",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/src/ast.js

@@ -496,86 +496,40 @@ export class Ast {
     Ast.number(ctx, -1 * v1);
   }
 
-  static add(ctx, coord) {
-    const n2 = Ast.node(ctx, Ast.pop(ctx));
-    const n1 = Ast.node(ctx, Ast.pop(ctx));
-    const v2 = n2.elts[0];
-    const v1 = n1.elts[0];
-    if (n1.tag !== "NUM" || n2.tag !== "NUM") {
-      Ast.push(ctx, {
-        tag: "ADD",
-        elts: [n1, n2],
-        coord
-      });
-    } else {
-      Ast.number(ctx, +v1 + +v2);
-    }
+  static add(ctx) {
+    const n2 = Ast.pop(ctx);
+    const n1 = Ast.pop(ctx);
+    Ast.push(ctx, { tag: "ADD", elts: [n1, n2] });
   }
 
   static sub(ctx) {
-    const n2 = Ast.node(ctx, Ast.pop(ctx));
-    const n1 = Ast.node(ctx, Ast.pop(ctx));
-    const v2 = n2.elts[0];
-    const v1 = n1.elts[0];
-    if (n1.tag !== "NUM" || n2.tag !== "NUM") {
-      Ast.push(ctx, { tag: "SUB", elts: [n1, n2] });
-    } else {
-      Ast.number(ctx, +v1 - +v2);
-    }
+    const n2 = Ast.pop(ctx);
+    const n1 = Ast.pop(ctx);
+    Ast.push(ctx, { tag: "SUB", elts: [n1, n2] });
   }
 
-  // static mul(ctx) {
-  //   let n2 = Ast.node(ctx, Ast.pop(ctx));
-  //   let n1 = Ast.node(ctx, Ast.pop(ctx));
-  //   const v2 = n2.elts[0];
-  //   const v1 = n1.elts[0];
-  //   if (n1.tag === undefined) {
-  //     n1 = n1.elts[0];
-  //   }
-  //   if (n2.tag === undefined) {
-  //     n2 = n2.elts[0];
-  //   }
-  //   if (n1.tag !== "NUM" || n2.tag !== "NUM") {
-  //     Ast.push(ctx, { tag: "MUL", elts: [n2, n1] });
-  //   } else {
-  //     Ast.number(ctx, +v1 * +v2);
-  //   }
-  // }
+  static mul(ctx) {
+    const n2 = Ast.pop(ctx);
+    const n1 = Ast.pop(ctx);
+    Ast.push(ctx, { tag: "MUL", elts: [n1, n2] });
+  }
 
   static div(ctx) {
-    const n2 = Ast.node(ctx, Ast.pop(ctx));
-    const n1 = Ast.node(ctx, Ast.pop(ctx));
-    const v2 = n2.elts[0];
-    const v1 = n1.elts[0];
-    if (n1.tag !== "NUM" || n2.tag !== "NUM") {
-      Ast.push(ctx, { tag: "DIV", elts: [n1, n2] });
-    } else {
-      Ast.number(ctx, +v1 / +v2);
-    }
+    const n2 = Ast.pop(ctx);
+    const n1 = Ast.pop(ctx);
+    Ast.push(ctx, { tag: "DIV", elts: [n1, n2] });
   }
 
   static mod(ctx) {
-    const n2 = Ast.node(ctx, Ast.pop(ctx));
-    const n1 = Ast.node(ctx, Ast.pop(ctx));
-    const v1 = n1.elts[0];
-    const v2 = n2.elts[0];
-    if (n1.tag !== "NUM" || n2.tag !== "NUM") {
-      Ast.push(ctx, { tag: "MOD", elts: [n1, n2] });
-    } else {
-      Ast.number(ctx, +v1 % +v2);
-    }
+    const n2 = Ast.pop(ctx);
+    const n1 = Ast.pop(ctx);
+    Ast.push(ctx, { tag: "MOD", elts: [n1, n2] });
   }
 
   static pow(ctx) {
-    const n2 = Ast.node(ctx, Ast.pop(ctx));
-    const n1 = Ast.node(ctx, Ast.pop(ctx));
-    const v2 = n2.elts[0];
-    const v1 = n1.elts[0];
-    if (n1.tag !== "NUM" || n2.tag !== "NUM") {
-      Ast.push(ctx, { tag: "POW", elts: [n1, n2] });
-    } else {
-      Ast.number(ctx, Math.pow(+v1, +v2));
-    }
+    const n2 = Ast.pop(ctx);
+    const n1 = Ast.pop(ctx);
+    Ast.push(ctx, { tag: "POW", elts: [n1, n2] });
   }
 
   static concat(ctx) {

package/src/folder.js

@@ -25,9 +25,9 @@ export class Folder {
       PARENS: Folder.unaryExpr,
       APPLY: Folder.apply,
       LAMBDA: Folder.lambda,
-      // "MUL": mul,
-      // "DIV": div,
-      // "SUB": sub,
+      MUL: Folder.mul,
+      DIV: Folder.div,
+      SUB: Folder.sub,
       TAG: Folder.tag,
       ADD: Folder.add,
       POW: Folder.pow,
@@ -161,6 +161,24 @@ export class Folder {
     Ast.add(Folder.#ctx);
   }
 
+  static sub(node) {
+    Folder.#visit(node.elts[0]);
+    Folder.#visit(node.elts[1]);
+    Ast.sub(Folder.#ctx);
+  }
+
+  static mul(node) {
+    Folder.#visit(node.elts[0]);
+    Folder.#visit(node.elts[1]);
+    Ast.mul(Folder.#ctx);
+  }
+
+  static div(node) {
+    Folder.#visit(node.elts[0]);
+    Folder.#visit(node.elts[1]);
+    Ast.div(Folder.#ctx);
+  }
+
   static pow(node) {
     Folder.#visit(node.elts[0]);
     Folder.#visit(node.elts[1]);

package/src/folder.spec.js

@@ -2,7 +2,7 @@ import { Folder } from "./folder.js";
 import { Ast } from "./ast.js";
 
 describe("folder", () => {
-  it("should fold 'add 2 3' to 5", () => {
+  it("should pass 'add 2 3' through as ADD node", () => {
     // Arrange
     const ctx = {
       state: {
@@ -35,8 +35,44 @@ describe("folder", () => {
     const resultId = ctx.state.nodeStack.pop();
     const resultNode = ctx.state.nodePool[resultId];
 
-    // Assert
-    expect(resultNode.tag).toBe("NUM");
-    expect(resultNode.elts[0]).toBe("5");
+    // Assert - arithmetic is deferred to compiler, not folded
+    expect(resultNode.tag).toBe("ADD");
+    expect(resultNode.elts.length).toBe(2);
+    // elts are nids (intern recursively interns object elts)
+    const n1 = Ast.node(ctx, resultNode.elts[0]);
+    const n2 = Ast.node(ctx, resultNode.elts[1]);
+    expect(n1.tag).toBe("NUM");
+    expect(n1.elts[0]).toBe("2");
+    expect(n2.tag).toBe("NUM");
+    expect(n2.elts[0]).toBe("3");
+  });
+
+  it("should pass 'pow 2 3' through as POW node", () => {
+    const ctx = {
+      state: {
+        nodePool: ["unused"],
+        nodeStack: [],
+        nodeStackStack: [],
+        nodeMap: {},
+        env: [{ name: "global", lexicon: {} }]
+      }
+    };
+
+    const n1Id = Ast.intern(ctx, { tag: "NUM", elts: ["2"] });
+    const n2Id = Ast.intern(ctx, { tag: "NUM", elts: ["3"] });
+    const powNodeId = Ast.intern(ctx, { tag: "POW", elts: [n1Id, n2Id] });
+
+    Folder.fold(ctx, powNodeId);
+    const resultId = ctx.state.nodeStack.pop();
+    const resultNode = ctx.state.nodePool[resultId];
+
+    expect(resultNode.tag).toBe("POW");
+    expect(resultNode.elts.length).toBe(2);
+    const n1 = Ast.node(ctx, resultNode.elts[0]);
+    const n2 = Ast.node(ctx, resultNode.elts[1]);
+    expect(n1.tag).toBe("NUM");
+    expect(n1.elts[0]).toBe("2");
+    expect(n2.tag).toBe("NUM");
+    expect(n2.elts[0]).toBe("3");
   });
 });

package/src/parser.spec.js

@@ -370,47 +370,36 @@ describe("parser integration tests", () => {
     expect(errorNode.tag).toBe("ERROR");
   });
 
-  it("should perform parse-time evaluation for adding two numbers", async () => {
-    // Use basis lexicon which includes add function
-    // Act - parse a simple addition expression
+  it("should parse 'add 123 456' as ADD node with operands", async () => {
+    // Arithmetic is deferred to the compiler, not folded at parse time
     const result = await parser.parse(0, "add 123 456..", basisLexicon);
-    console.log(
-      "TEST",
-      "result=" + JSON.stringify(result, null, 2),
-    );
 
     // Assert
     expect(result).toHaveProperty("root");
 
-    // Verify basic structure
     const rootId = result.root;
     const rootNode = result[rootId];
     expect(rootNode.tag).toBe("PROG");
 
-    // Find the result node - expecting a single NUM node with the sum
-    let resultNode = null;
-
-    // Check all nodes for the result of evaluation (123 + 456 = 579)
+    // Find the ADD node
+    let addNode = null;
     for (const key in result) {
       if (key !== "root") {
         const node = result[key];
-        if (node.tag === "NUM" && node.elts[0] === "579") {
-          resultNode = node;
+        if (node.tag === "ADD") {
+          addNode = node;
           break;
         }
       }
     }
 
-    // We should find a node with the computed value (579)
-    expect(resultNode).not.toBeNull();
-    expect(resultNode.tag).toBe("NUM");
-    expect(resultNode.elts[0]).toBe("579");
+    expect(addNode).not.toBeNull();
+    expect(addNode.tag).toBe("ADD");
+    expect(addNode.elts.length).toBe(2);
 
-    // The original numbers should not be in the final AST
-    // if parse-time evaluation is working correctly
+    // Original operands should be preserved
     let found123 = false;
     let found456 = false;
-
     for (const key in result) {
       if (key !== "root") {
         const node = result[key];
@@ -420,11 +409,8 @@ describe("parser integration tests", () => {
         }
       }
     }
-
-    // The original operands should not be in the final AST
-    // if they were properly evaluated at parse time
-    expect(found123).toBe(false);
-    expect(found456).toBe(false);
+    expect(found123).toBe(true);
+    expect(found456).toBe(true);
   });
 
   // Tests for escaped quotes

package/src/unparse.js

@@ -166,10 +166,10 @@ function unparseNode(node, lexicon, indent = 0, options = {}) {
     return "";
 
   case "LAMBDA":
-    // Lambda function
-    if (node.elts && node.elts.length >= 3) {
-      const params = node.elts[1];
-      const body = node.elts[2];
+    // Lambda function: elts = [param_names_list, body, pattern_list, init_list]
+    if (node.elts && node.elts.length >= 2) {
+      const params = node.elts[0];
+      const body = node.elts[1];
 
       // Extract parameter names
       let paramStr = "";