@graffiticode/parser 1.4.1 → 1.4.3

package/.claude/settings.local.json

@@ -8,7 +8,8 @@
       "Bash(grep:*)",
       "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\")"
+      "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\")",
+      "Bash(git:*)"
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiticode/parser",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -22,6 +22,6 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@graffiticode/basis": "^1.6.4"
+    "@graffiticode/basis": "^1.7.0"
   }
 }

package/src/ast.js

@@ -532,12 +532,18 @@ export class Ast {
     Ast.push(ctx, { tag: "POW", elts: [n1, n2] });
   }
 
-  static concat(ctx) {
-    const n1 = Ast.node(ctx, Ast.pop(ctx));
-    Ast.push(ctx, {
-      tag: "CONCAT",
-      elts: [n1]
-    });
+  static concat(ctx, count) {
+    // Chain binary CONCATs from the parts on the stack.
+    // E.g. 3 parts [a, b, c] becomes CONCAT(CONCAT(a, b), c)
+    const parts = [];
+    for (let i = 0; i < count; i++) {
+      parts.unshift(Ast.pop(ctx));
+    }
+    let result = parts[0];
+    for (let i = 1; i < parts.length; i++) {
+      result = { tag: "CONCAT", elts: [result, parts[i]] };
+    }
+    Ast.push(ctx, result);
   }
 
   static eq(ctx) {

package/src/folder.js

@@ -187,7 +187,8 @@ export class Folder {
 
   static concat(node) {
     Folder.#visit(node.elts[0]);
-    Ast.concat(Folder.#ctx);
+    Folder.#visit(node.elts[1]);
+    Ast.concat(Folder.#ctx, 2);
   }
 
   static mod(node) {

package/src/parse.js

@@ -108,8 +108,8 @@ export const parse = (function () {
     null: { tk: 0x15, cls: "val", length: 0 },
     val: { tk: 1, name: "VAL", cls: "function", length: 2, arity: 2 },
     key: { tk: 1, name: "KEY", cls: "function", length: 2, arity: 2 },
-    len: { tk: 1, name: "LEN", cls: "function", length: 1, arity: 1 },
-    concat: { tk: 1, name: "CONCAT", cls: "function", length: 1, arity: 1 },
+    length: { tk: 1, name: "LEN", cls: "function", length: 1, arity: 1 },
+    concat: { tk: 1, name: "CONCAT", cls: "function", length: 2, arity: 2 },
     add: { tk: 1, name: "ADD", cls: "function", length: 2, arity: 2 },
     mul: { tk: 1, name: "MUL", cls: "function", length: 2, arity: 2 },
     pow: { tk: 1, name: "POW", cls: "function", length: 2, arity: 2 },
@@ -362,9 +362,9 @@ export const parse = (function () {
           const processedSuffix = processEscapeSequences(lexeme);
           Ast.string(ctx, processedSuffix, getCoord(ctx)); // strip quotes;
           countCounter(ctx);
-          Ast.list(ctx, ctx.state.exprc);
+          const count = ctx.state.exprc;
           stopCounter(ctx);
-          Ast.concat(ctx);
+          Ast.concat(ctx, count);
           cc.cls = "string";
           return cc;
         });
@@ -1240,7 +1240,7 @@ export const parse = (function () {
     }
 
     // `abc` --> "abc"
-    // `a${x}c` --> concat ["a", x, "b"]
+    // `a${x}c` --> concat (concat "a" x) "c"
     function string(ctx, c) {
       const quoteChar = c;
       ctx.state.quoteCharStack.push(c);

package/src/unparse.js

@@ -100,7 +100,7 @@ function unparseNode(node, lexicon, indent = 0, options = {}) {
     if (opts.compact) {
       // Compact mode: inline list
       const items = node.elts.map(elt => unparseNode(elt, lexicon, indent, opts));
-      return "[" + items.join(", ") + "]";
+      return "[" + items.join(" ") + "]";
     } else {
       // Pretty print with each element on a new line
       const innerIndent = indent + opts.indentSize;
@@ -181,9 +181,9 @@ function unparseNode(node, lexicon, indent = 0, options = {}) {
       const bodyStr = unparseNode(body, lexicon, indent, opts);
 
       if (paramStr) {
-        return `\\${paramStr} . ${bodyStr}`;
+        return `<${paramStr}: ${bodyStr}>`;
       } else {
-        return `\\. ${bodyStr}`;
+        return `<: ${bodyStr}>`;
       }
     }
     return "";

package/src/unparse.spec.js

@@ -79,13 +79,13 @@ describe("unparse", () => {
     it("should unparse list with multiple elements", async () => {
       const source = "[1, 2, 3]..";
       const unparsed = await testRoundTrip(source);
-      expect(unparsed).toBe("[1, 2, 3]..");
+      expect(unparsed).toBe("[1 2 3]..");
     });
 
     it("should unparse nested lists", async () => {
       const source = "[[1, 2], [3, 4]]..";
       const unparsed = await testRoundTrip(source);
-      expect(unparsed).toBe("[[1, 2], [3, 4]]..");
+      expect(unparsed).toBe("[[1 2] [3 4]]..");
     });
 
     it("should unparse empty record", async () => {
@@ -162,6 +162,12 @@ describe("unparse", () => {
       expect(unparsed).toBe("concat 'hello' ' world'..");
     });
 
+    it("should unparse template literal", async () => {
+      const source = 'let x = "world"..`hello ${x}`..';
+      const unparsed = await testRoundTrip(source);
+      expect(unparsed).toBe('concat concat "hello " "world" ""..');
+    });
+
     it.skip("should unparse complex arithmetic expression", async () => {
       const source = "mul (add 1 2) 3..";
       const unparsed = await testRoundTrip(source);
@@ -207,6 +213,12 @@ describe("unparse", () => {
       const unparsed = await testRoundTrip(source);
       expect(unparsed).toBe("foo (bar 42)..");
     });
+
+    it("should unparse map with lambda and list", async () => {
+      const source = 'map (<x: add x 10>) [\n  1\n  2\n  3\n]..';
+      const unparsed = await testRoundTrip(source);
+      expect(unparsed).toBe("map (<x: add x 10>) [1 2 3]..");
+    });
   });
 
   describe("control flow", () => {
@@ -337,7 +349,7 @@ describe("unparse", () => {
     it("should support compact option", async () => {
       const source = "[1, 2, 3]..";
       const reformatted = await parser.reformat(0, source, basisLexicon, { compact: true });
-      expect(reformatted).toBe("[1, 2, 3]..");
+      expect(reformatted).toBe("[1 2 3]..");
     });
 
     it("should support custom indent size", async () => {