@weborigami/language 0.1.0 → 0.2.1

package/test/compiler/parse.test.js

@@ -1,39 +1,52 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
 import { parse } from "../../src/compiler/parse.js";
+import { undetermined } from "../../src/compiler/parserHelpers.js";
 import * as ops from "../../src/runtime/ops.js";
 import { stripCodeLocations } from "./stripCodeLocations.js";
 
 describe("Origami parser", () => {
-  test("absoluteFilePath", () => {
-    assertParse("absoluteFilePath", "/foo/bar", [
-      [ops.filesRoot],
-      [ops.literal, "foo/"],
-      [ops.literal, "bar"],
+  test("additiveExpression", () => {
+    assertParse("additiveExpression", "1 + 2", [
+      ops.addition,
+      [ops.literal, 1],
+      [ops.literal, 2],
+    ]);
+    assertParse("additiveExpression", "5 - 4", [
+      ops.subtraction,
+      [ops.literal, 5],
+      [ops.literal, 4],
     ]);
   });
 
-  test("array", () => {
-    assertParse("array", "[]", [ops.array]);
-    assertParse("array", "[1, 2, 3]", [
+  test("arrayLiteral", () => {
+    assertParse("arrayLiteral", "[]", [ops.array]);
+    assertParse("arrayLiteral", "[1, 2, 3]", [
       ops.array,
       [ops.literal, 1],
       [ops.literal, 2],
       [ops.literal, 3],
     ]);
-    assertParse("array", "[ 1 , 2 , 3 ]", [
+    assertParse("arrayLiteral", "[ 1 , 2 , 3 ]", [
       ops.array,
       [ops.literal, 1],
       [ops.literal, 2],
       [ops.literal, 3],
     ]);
-    assertParse("array", "[ 1, ...[2, 3]]", [
+    assertParse("arrayLiteral", "[1,,,4]", [
+      ops.array,
+      [ops.literal, 1],
+      [ops.literal, undefined],
+      [ops.literal, undefined],
+      [ops.literal, 4],
+    ]);
+    assertParse("arrayLiteral", "[ 1, ...[2, 3]]", [
       ops.merge,
       [ops.array, [ops.literal, 1]],
       [ops.array, [ops.literal, 2], [ops.literal, 3]],
     ]);
     assertParse(
-      "array",
+      "arrayLiteral",
       `[
         1
         2
@@ -43,27 +56,237 @@ describe("Origami parser", () => {
     );
   });
 
-  test("callTarget", () => {
-    assertParse("callTarget", "foo", [ops.builtin, "foo"]);
-    assertParse("callTarget", "foo.js", [ops.scope, "foo.js"]);
-    assertParse("callTarget", "[1, 2]", [
-      ops.array,
-      [ops.literal, 1],
-      [ops.literal, 2],
+  test("arrowFunction", () => {
+    assertParse("arrowFunction", "() => foo", [
+      ops.lambda,
+      [],
+      [ops.scope, "foo"],
+    ]);
+    assertParse("arrowFunction", "x => y", [
+      ops.lambda,
+      ["x"],
+      [ops.scope, "y"],
+    ]);
+    assertParse("arrowFunction", "(a, b, c) ⇒ fn(a, b, c)", [
+      ops.lambda,
+      ["a", "b", "c"],
+      [
+        [ops.builtin, "fn"],
+        [ops.scope, "a"],
+        [ops.scope, "b"],
+        [ops.scope, "c"],
+      ],
+    ]);
+    assertParse("arrowFunction", "a => b => fn(a, b)", [
+      ops.lambda,
+      ["a"],
+      [
+        ops.lambda,
+        ["b"],
+        [
+          [ops.builtin, "fn"],
+          [ops.scope, "a"],
+          [ops.scope, "b"],
+        ],
+      ],
     ]);
   });
 
-  test("doubleSlashPath", () => {
-    assertParse("doubleSlashPath", "//example.com", [
-      [ops.literal, "example.com"],
+  test("bitwiseAndExpression", () => {
+    assertParse("bitwiseAndExpression", "5 & 3", [
+      ops.bitwiseAnd,
+      [ops.literal, 5],
+      [ops.literal, 3],
     ]);
-    assertParse("doubleSlashPath", "//example.com/index.html", [
-      [ops.literal, "example.com/"],
-      [ops.literal, "index.html"],
+  });
+
+  test("bitwiseOrExpression", () => {
+    assertParse("bitwiseOrExpression", "5 | 3", [
+      ops.bitwiseOr,
+      [ops.literal, 5],
+      [ops.literal, 3],
     ]);
-    assertParse("doubleSlashPath", "//localhost:5000/foo", [
-      [ops.literal, "localhost:5000/"],
-      [ops.literal, "foo"],
+  });
+
+  test("bitwiseXorExpression", () => {
+    assertParse("bitwiseXorExpression", "5 ^ 3", [
+      ops.bitwiseXor,
+      [ops.literal, 5],
+      [ops.literal, 3],
+    ]);
+  });
+
+  test("callExpression", () => {
+    assertParse("callExpression", "fn()", [[ops.builtin, "fn"], undefined]);
+    assertParse("callExpression", "foo.js(arg)", [
+      [ops.scope, "foo.js"],
+      [ops.scope, "arg"],
+    ]);
+    assertParse("callExpression", "fn(a, b)", [
+      [ops.builtin, "fn"],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+    ]);
+    assertParse("callExpression", "foo.js( a , b )", [
+      [ops.scope, "foo.js"],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+    ]);
+    assertParse("callExpression", "fn()(arg)", [
+      [[ops.builtin, "fn"], undefined],
+      [ops.scope, "arg"],
+    ]);
+    assertParse("callExpression", "tree/", [ops.unpack, [ops.scope, "tree/"]]);
+    assertParse("callExpression", "tree/foo/bar", [
+      ops.traverse,
+      [ops.scope, "tree/"],
+      [ops.literal, "foo/"],
+      [ops.literal, "bar"],
+    ]);
+    assertParse("callExpression", "tree/foo/bar/", [
+      ops.traverse,
+      [ops.scope, "tree/"],
+      [ops.literal, "foo/"],
+      [ops.literal, "bar/"],
+    ]);
+    assertParse("callExpression", "/foo/bar", [
+      ops.traverse,
+      [ops.rootDirectory, [ops.literal, "foo/"]],
+      [ops.literal, "bar"],
+    ]);
+    assertParse("callExpression", "foo.js()/key", [
+      ops.traverse,
+      [[ops.scope, "foo.js"], undefined],
+      [ops.literal, "key"],
+    ]);
+    assertParse("callExpression", "tree/key()", [
+      [ops.traverse, [ops.scope, "tree/"], [ops.literal, "key"]],
+      undefined,
+    ]);
+    assertParse("callExpression", "(tree)/", [ops.unpack, [ops.scope, "tree"]]);
+    assertParse("callExpression", "fn()/key()", [
+      [ops.traverse, [[ops.builtin, "fn"], undefined], [ops.literal, "key"]],
+      undefined,
+    ]);
+    assertParse("callExpression", "(foo.js())('arg')", [
+      [[ops.scope, "foo.js"], undefined],
+      [ops.literal, "arg"],
+    ]);
+    assertParse("callExpression", "fn('a')('b')", [
+      [
+        [ops.builtin, "fn"],
+        [ops.literal, "a"],
+      ],
+      [ops.literal, "b"],
+    ]);
+    assertParse("callExpression", "(foo.js())(a, b)", [
+      [[ops.scope, "foo.js"], undefined],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+    ]);
+    assertParse("callExpression", "{ a: 1, b: 2}/b", [
+      ops.traverse,
+      [ops.object, ["a", [ops.literal, 1]], ["b", [ops.literal, 2]]],
+      [ops.literal, "b"],
+    ]);
+    assertParse("callExpression", "indent`hello`", [
+      [ops.builtin, "indent"],
+      [ops.literal, ["hello"]],
+    ]);
+    assertParse("callExpression", "fn.js`Hello, world.`", [
+      [ops.scope, "fn.js"],
+      [ops.literal, ["Hello, world."]],
+    ]);
+    assertParse("callExpression", "files:src/assets", [
+      ops.traverse,
+      [
+        [ops.builtin, "files:"],
+        [ops.literal, "src/"],
+      ],
+      [ops.literal, "assets"],
+    ]);
+    assertParse("callExpression", "new:(js:Date, '2025-01-01')", [
+      [ops.builtin, "new:"],
+      [
+        [ops.builtin, "js:"],
+        [ops.literal, "Date"],
+      ],
+      [ops.literal, "2025-01-01"],
+    ]);
+    assertParse("callExpression", "map(markdown, mdHtml)", [
+      [ops.builtin, "map"],
+      [ops.scope, "markdown"],
+      [ops.scope, "mdHtml"],
+    ]);
+    assertParse("callExpression", "package:@weborigami/dropbox/auth(creds)", [
+      [
+        ops.traverse,
+        [
+          [ops.builtin, "package:"],
+          [ops.literal, "@weborigami/"],
+        ],
+        [ops.literal, "dropbox/"],
+        [ops.literal, "auth"],
+      ],
+      [ops.scope, "creds"],
+    ]);
+  });
+
+  test("commaExpression", () => {
+    assertParse("commaExpression", "1", [ops.literal, 1]);
+    assertParse("commaExpression", "a, b, c", [
+      ops.comma,
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+      [ops.scope, "c"],
+    ]);
+  });
+
+  test("conditionalExpression", () => {
+    assertParse("conditionalExpression", "1", [ops.literal, 1]);
+    assertParse("conditionalExpression", "true ? 1 : 0", [
+      ops.conditional,
+      [ops.scope, "true"],
+      [ops.lambda, [], [ops.literal, "1"]],
+      [ops.lambda, [], [ops.literal, "0"]],
+    ]);
+    assertParse("conditionalExpression", "false ? () => 1 : 0", [
+      ops.conditional,
+      [ops.scope, "false"],
+      [ops.lambda, [], [ops.lambda, [], [ops.literal, "1"]]],
+      [ops.lambda, [], [ops.literal, "0"]],
+    ]);
+    assertParse("conditionalExpression", "false ? =1 : 0", [
+      ops.conditional,
+      [ops.scope, "false"],
+      [ops.lambda, [], [ops.lambda, ["_"], [ops.literal, "1"]]],
+      [ops.lambda, [], [ops.literal, "0"]],
+    ]);
+  });
+
+  test("equalityExpression", () => {
+    assertParse("equalityExpression", "1 === 1", [
+      ops.strictEqual,
+      [ops.literal, 1],
+      [ops.literal, 1],
+    ]);
+    assertParse("equalityExpression", "a === b === c", [
+      ops.strictEqual,
+      [ops.strictEqual, [undetermined, "a"], [undetermined, "b"]],
+      [undetermined, "c"],
+    ]);
+    assertParse("equalityExpression", "1 !== 1", [
+      ops.notStrictEqual,
+      [ops.literal, 1],
+      [ops.literal, 1],
+    ]);
+  });
+
+  test("exponentiationExpression", () => {
+    assertParse("exponentiationExpression", "2 ** 2 ** 3", [
+      ops.exponentiation,
+      [ops.literal, 2],
+      [ops.exponentiation, [ops.literal, 2], [ops.literal, 3]],
     ]);
   });
 
@@ -114,7 +337,7 @@ describe("Origami parser", () => {
 
     // Single slash at start of something = absolute file path
     assertParse("expression", "/path", [
-      [ops.filesRoot],
+      ops.rootDirectory,
       [ops.literal, "path"],
     ]);
 
@@ -128,136 +351,108 @@ describe("Origami parser", () => {
       ],
     ]);
 
+    // Slash on its own is the root folder
+    assertParse("expression", "keys /", [
+      [ops.builtin, "keys"],
+      [ops.rootDirectory],
+    ]);
+
     assertParse("expression", "'Hello' -> test.orit", [
       [ops.scope, "test.orit"],
       [ops.literal, "Hello"],
     ]);
-  });
-
-  test("functionComposition", () => {
-    assertParse("functionComposition", "fn()", [
+    assertParse("expression", "obj.json", [ops.scope, "obj.json"]);
+    assertParse("expression", "(fn a, b, c)", [
       [ops.builtin, "fn"],
-      undefined,
+      [undetermined, "a"],
+      [undetermined, "b"],
+      [undetermined, "c"],
     ]);
-    assertParse("functionComposition", "foo.js(arg)", [
-      [ops.scope, "foo.js"],
-      [ops.scope, "arg"],
-    ]);
-    assertParse("functionComposition", "fn(a, b)", [
-      [ops.builtin, "fn"],
-      [ops.scope, "a"],
-      [ops.scope, "b"],
-    ]);
-    assertParse("functionComposition", "foo.js( a , b )", [
-      [ops.scope, "foo.js"],
-      [ops.scope, "a"],
-      [ops.scope, "b"],
+    assertParse("expression", "foo.bar('hello', 'world')", [
+      [ops.scope, "foo.bar"],
+      [ops.literal, "hello"],
+      [ops.literal, "world"],
     ]);
-    assertParse("functionComposition", "fn()(arg)", [
-      [[ops.builtin, "fn"], undefined],
-      [ops.scope, "arg"],
-    ]);
-    assertParse("functionComposition", "foo.js()/key", [
-      ops.traverse,
-      [[ops.scope, "foo.js"], undefined],
-      [ops.literal, "key"],
-    ]);
-    assertParse("functionComposition", "tree/key()", [
-      [ops.traverse, [ops.scope, "tree/"], [ops.literal, "key"]],
-      undefined,
+    assertParse("expression", "(key)('a')", [
+      [ops.scope, "key"],
+      [ops.literal, "a"],
     ]);
-    assertParse("functionComposition", "(tree)/", [
-      ops.unpack,
-      [ops.scope, "tree"],
+    assertParse("expression", "1", [ops.literal, 1]);
+    assertParse("expression", "{ a: 1, b: 2 }", [
+      ops.object,
+      ["a", [ops.literal, 1]],
+      ["b", [ops.literal, 2]],
     ]);
-    assertParse("functionComposition", "fn()/key()", [
-      [ops.traverse, [[ops.builtin, "fn"], undefined], [ops.literal, "key"]],
-      undefined,
+    assertParse("expression", "serve { index.html: 'hello' }", [
+      [ops.builtin, "serve"],
+      [ops.object, ["index.html", [ops.literal, "hello"]]],
     ]);
-    assertParse("functionComposition", "(foo.js())('arg')", [
-      [[ops.scope, "foo.js"], undefined],
-      [ops.literal, "arg"],
+    assertParse("expression", "fn =`x`", [
+      [ops.builtin, "fn"],
+      [ops.lambda, ["_"], [ops.template, [ops.literal, ["x"]]]],
     ]);
-    assertParse("functionComposition", "fn('a')('b')", [
+    assertParse("expression", "copy app.js(formulas), files:snapshot", [
+      [ops.builtin, "copy"],
       [
-        [ops.builtin, "fn"],
-        [ops.literal, "a"],
+        [ops.scope, "app.js"],
+        [ops.scope, "formulas"],
       ],
-      [ops.literal, "b"],
-    ]);
-    assertParse("functionComposition", "(foo.js())(a, b)", [
-      [[ops.scope, "foo.js"], undefined],
-      [ops.scope, "a"],
-      [ops.scope, "b"],
-    ]);
-    assertParse("functionComposition", "{ a: 1, b: 2}/b", [
-      ops.traverse,
-      [ops.object, ["a", [ops.literal, 1]], ["b", [ops.literal, 2]]],
-      [ops.literal, "b"],
-    ]);
-    assertParse("functionComposition", "fn arg", [
-      [ops.builtin, "fn"],
-      [ops.scope, "arg"],
-    ]);
-    assertParse("functionComposition", "page.ori 'a', 'b'", [
-      [ops.scope, "page.ori"],
-      [ops.literal, "a"],
-      [ops.literal, "b"],
-    ]);
-    assertParse("functionComposition", "fn a(b), c", [
-      [ops.builtin, "fn"],
       [
-        [ops.builtin, "a"],
-        [ops.scope, "b"],
+        [ops.builtin, "files:"],
+        [ops.literal, "snapshot"],
       ],
-      [ops.scope, "c"],
     ]);
-    assertParse("functionComposition", "foo.js bar.ori 'arg'", [
-      [ops.scope, "foo.js"],
+    assertParse("expression", "map =`<li>${_}</li>`", [
+      [ops.builtin, "map"],
       [
-        [ops.scope, "bar.ori"],
-        [ops.literal, "arg"],
+        ops.lambda,
+        ["_"],
+        [
+          ops.template,
+          [ops.literal, ["<li>", "</li>"]],
+          [ops.concat, [ops.scope, "_"]],
+        ],
       ],
     ]);
-    assertParse("functionComposition", "(fn()) 'arg'", [
-      [[ops.builtin, "fn"], undefined],
-      [ops.literal, "arg"],
+    assertParse("expression", `https://example.com/about/`, [
+      [ops.builtin, "https:"],
+      [ops.literal, "example.com/"],
+      [ops.literal, "about/"],
     ]);
-    assertParse("functionComposition", "tree/key arg", [
-      [ops.traverse, [ops.scope, "tree/"], [ops.literal, "key"]],
-      [ops.scope, "arg"],
+    assertParse("expression", "tag`Hello, ${name}!`", [
+      [ops.builtin, "tag"],
+      [ops.literal, ["Hello, ", "!"]],
+      [ops.concat, [ops.scope, "name"]],
     ]);
-    assertParse("functionComposition", "new:(js:Date, '2025-01-01')", [
-      [ops.builtin, "new:"],
+    assertParse("expression", "(post, slug) => fn.js(post, slug)", [
+      ops.lambda,
+      ["post", "slug"],
       [
-        [ops.builtin, "js:"],
-        [ops.literal, "Date"],
+        [ops.scope, "fn.js"],
+        [ops.scope, "post"],
+        [ops.scope, "slug"],
       ],
-      [ops.literal, "2025-01-01"],
     ]);
-    assertParse("functionComposition", "map(markdown, mdHtml)", [
-      [ops.builtin, "map"],
-      [ops.scope, "markdown"],
-      [ops.scope, "mdHtml"],
-    ]);
-    assertParse(
-      "functionComposition",
-      "package:@weborigami/dropbox/auth(creds)",
-      [
-        [
-          [ops.builtin, "package:"],
-          [ops.literal, "@weborigami/"],
-          [ops.literal, "dropbox/"],
-          [ops.literal, "auth"],
-        ],
-        [ops.scope, "creds"],
-      ]
-    );
-  });
 
-  test("functionReference", () => {
-    assertParse("functionReference", "json", [ops.builtin, "json"]);
-    assertParse("functionReference", "greet.js", [ops.scope, "greet.js"]);
+    // Verify parser treatment of identifiers containing operators
+    assertParse("expression", "a + b", [
+      ops.addition,
+      [undetermined, "a"],
+      [undetermined, "b"],
+    ]);
+    assertParse("expression", "a+b", [ops.scope, "a+b"]);
+    assertParse("expression", "a - b", [
+      ops.subtraction,
+      [undetermined, "a"],
+      [undetermined, "b"],
+    ]);
+    assertParse("expression", "a-b", [ops.scope, "a-b"]);
+    assertParse("expression", "a&b", [ops.scope, "a&b"]);
+    assertParse("expression", "a & b", [
+      ops.bitwiseAnd,
+      [undetermined, "a"],
+      [undetermined, "b"],
+    ]);
   });
 
   test("group", () => {
@@ -270,15 +465,14 @@ describe("Origami parser", () => {
     ]);
   });
 
-  test("homeTree", () => {
-    assertParse("homeTree", "~", [ops.homeTree]);
+  test("homeDirectory", () => {
+    assertParse("homeDirectory", "~", [ops.homeDirectory]);
   });
 
   test("host", () => {
     assertParse("host", "abc", [ops.literal, "abc"]);
     assertParse("host", "abc:123", [ops.literal, "abc:123"]);
     assertParse("host", "foo\\ bar", [ops.literal, "foo bar"]);
-    assertParse("host", "example.com/", [ops.literal, "example.com/"]);
   });
 
   test("identifier", () => {
@@ -288,37 +482,41 @@ describe("Origami parser", () => {
     assertParse("identifier", "x-y-z", "x-y-z", false);
   });
 
-  test("lambda", () => {
-    assertParse("lambda", "=message", [
-      ops.lambda,
-      ["_"],
-      [ops.scope, "message"],
+  test("implicitParenthesesCallExpression", () => {
+    assertParse("implicitParenthesesCallExpression", "fn arg", [
+      [ops.builtin, "fn"],
+      [undetermined, "arg"],
     ]);
-    assertParse("lambda", "=`Hello, ${name}.`", [
-      ops.lambda,
-      ["_"],
+    assertParse("implicitParenthesesCallExpression", "page.ori 'a', 'b'", [
+      [ops.scope, "page.ori"],
+      [ops.literal, "a"],
+      [ops.literal, "b"],
+    ]);
+    assertParse("implicitParenthesesCallExpression", "fn a(b), c", [
+      [ops.builtin, "fn"],
       [
-        ops.template,
-        [ops.literal, ["Hello, ", "."]],
-        [ops.concat, [ops.scope, "name"]],
+        [ops.builtin, "a"],
+        [ops.scope, "b"],
       ],
+      [undetermined, "c"],
     ]);
-    assertParse("lambda", "=indent`hello`", [
-      ops.lambda,
-      ["_"],
+    assertParse("implicitParenthesesCallExpression", "(fn()) 'arg'", [
+      [[ops.builtin, "fn"], undefined],
+      [ops.literal, "arg"],
+    ]);
+    assertParse("implicitParenthesesCallExpression", "tree/key arg", [
+      [ops.traverse, [ops.scope, "tree/"], [ops.literal, "key"]],
+      [undetermined, "arg"],
+    ]);
+    assertParse("implicitParenthesesCallExpression", "foo.js bar.ori 'arg'", [
+      [ops.scope, "foo.js"],
       [
-        [ops.builtin, "indent"],
-        [ops.literal, ["hello"]],
+        [ops.scope, "bar.ori"],
+        [ops.literal, "arg"],
       ],
     ]);
   });
 
-  test("leadingSlashPath", () => {
-    assertParse("leadingSlashPath", "/", []);
-    assertParse("leadingSlashPath", "/tree", [[ops.literal, "tree"]]);
-    assertParse("leadingSlashPath", "/tree/", [[ops.literal, "tree/"]]);
-  });
-
   test("list", () => {
     assertParse("list", "1", [[ops.literal, 1]]);
     assertParse("list", "1,2,3", [
@@ -348,76 +546,106 @@ describe("Origami parser", () => {
     ]);
   });
 
+  test("logicalAndExpression", () => {
+    assertParse("logicalAndExpression", "true && false", [
+      ops.logicalAnd,
+      [ops.scope, "true"],
+      [ops.lambda, [], [undetermined, "false"]],
+    ]);
+  });
+
+  test("logicalOrExpression", () => {
+    assertParse("logicalOrExpression", "1 || 0", [
+      ops.logicalOr,
+      [ops.literal, 1],
+      [ops.literal, 0],
+    ]);
+    assertParse("logicalOrExpression", "false || false || true", [
+      ops.logicalOr,
+      [ops.scope, "false"],
+      [ops.lambda, [], [undetermined, "false"]],
+      [ops.lambda, [], [undetermined, "true"]],
+    ]);
+    assertParse("logicalOrExpression", "1 || 2 && 0", [
+      ops.logicalOr,
+      [ops.literal, 1],
+      [ops.lambda, [], [ops.logicalAnd, [ops.literal, 2], [ops.literal, 0]]],
+    ]);
+  });
+
   test("multiLineComment", () => {
     assertParse("multiLineComment", "/*\nHello, world!\n*/", null, false);
   });
 
+  test("multiplicativeExpression", () => {
+    assertParse("multiplicativeExpression", "3 * 4", [
+      ops.multiplication,
+      [ops.literal, 3],
+      [ops.literal, 4],
+    ]);
+    assertParse("multiplicativeExpression", "5 / 2", [
+      ops.division,
+      [ops.literal, 5],
+      [ops.literal, 2],
+    ]);
+    assertParse("multiplicativeExpression", "6 % 5", [
+      ops.remainder,
+      [ops.literal, 6],
+      [ops.literal, 5],
+    ]);
+  });
+
   test("namespace", () => {
     assertParse("namespace", "js:", [ops.builtin, "js:"]);
   });
 
-  test("namespacePath", () => {
-    assertParse("namespacePath", "js:Date", [
-      [ops.builtin, "js:"],
-      [ops.literal, "Date"],
-    ]);
-    assertParse("namespacePath", "files:src/assets", [
-      [ops.builtin, "files:"],
-      [ops.literal, "src/"],
-      [ops.literal, "assets"],
-    ]);
-    assertParse("namespacePath", "foo://bar", [
-      [ops.builtin, "foo:"],
-      [ops.literal, "bar"],
-    ]);
-    assertParse("namespacePath", "http://example.com", [
-      [ops.builtin, "http:"],
-      [ops.literal, "example.com"],
+  test("nullishCoalescingExpression", () => {
+    assertParse("nullishCoalescingExpression", "a ?? b", [
+      ops.nullishCoalescing,
+      [ops.scope, "a"],
+      [ops.lambda, [], [undetermined, "b"]],
     ]);
-    assertParse("namespacePath", "https://example.com/foo/", [
-      [ops.builtin, "https:"],
-      [ops.literal, "example.com/"],
-      [ops.literal, "foo/"],
+    assertParse("nullishCoalescingExpression", "a ?? b ?? c", [
+      ops.nullishCoalescing,
+      [ops.scope, "a"],
+      [ops.lambda, [], [undetermined, "b"]],
+      [ops.lambda, [], [undetermined, "c"]],
     ]);
   });
 
-  test("number", () => {
-    assertParse("number", "123", [ops.literal, 123]);
-    assertParse("number", "-456", [ops.literal, -456]);
-    assertParse("number", ".5", [ops.literal, 0.5]);
-    assertParse("number", "123.45", [ops.literal, 123.45]);
-    assertParse("number", "-678.90", [ops.literal, -678.9]);
-    assertParse("number", "+123", [ops.literal, 123]);
-    assertParse("number", "+456.78", [ops.literal, 456.78]);
+  test("numericLiteral", () => {
+    assertParse("numericLiteral", "123", [ops.literal, 123]);
+    assertParse("numericLiteral", ".5", [ops.literal, 0.5]);
+    assertParse("numericLiteral", "123.45", [ops.literal, 123.45]);
   });
 
-  test("object", () => {
-    assertParse("object", "{}", [ops.object]);
-    assertParse("object", "{ a: 1, b }", [
+  test("objectLiteral", () => {
+    assertParse("objectLiteral", "{}", [ops.object]);
+    assertParse("objectLiteral", "{ a: 1, b }", [
       ops.object,
       ["a", [ops.literal, 1]],
       ["b", [ops.inherited, "b"]],
     ]);
-    assertParse("object", "{ sub: { a: 1 } }", [
+    assertParse("objectLiteral", "{ sub: { a: 1 } }", [
       ops.object,
       ["sub", [ops.object, ["a", [ops.literal, 1]]]],
     ]);
-    assertParse("object", "{ sub: { a/: 1 } }", [
+    assertParse("objectLiteral", "{ sub: { a/: 1 } }", [
       ops.object,
       ["sub", [ops.object, ["a/", [ops.literal, 1]]]],
     ]);
-    assertParse("object", `{ "a": 1, "b": 2 }`, [
+    assertParse("objectLiteral", `{ "a": 1, "b": 2 }`, [
       ops.object,
       ["a", [ops.literal, 1]],
       ["b", [ops.literal, 2]],
     ]);
-    assertParse("object", "{ a = b, b = 2 }", [
+    assertParse("objectLiteral", "{ a = b, b = 2 }", [
       ops.object,
       ["a", [ops.getter, [ops.scope, "b"]]],
       ["b", [ops.literal, 2]],
     ]);
     assertParse(
-      "object",
+      "objectLiteral",
       `{
         a = b
         b = 2
@@ -428,22 +656,22 @@ describe("Origami parser", () => {
         ["b", [ops.literal, 2]],
       ]
     );
-    assertParse("object", "{ a: { b: 1 } }", [
+    assertParse("objectLiteral", "{ a: { b: 1 } }", [
       ops.object,
       ["a", [ops.object, ["b", [ops.literal, 1]]]],
     ]);
-    assertParse("object", "{ a: { b = 1 } }", [
+    assertParse("objectLiteral", "{ a: { b = 1 } }", [
       ops.object,
       ["a", [ops.object, ["b", [ops.literal, 1]]]],
     ]);
-    assertParse("object", "{ a: { b = fn() } }", [
+    assertParse("objectLiteral", "{ a: { b = fn() } }", [
       ops.object,
       [
         "a/",
         [ops.object, ["b", [ops.getter, [[ops.builtin, "fn"], undefined]]]],
       ],
     ]);
-    assertParse("object", "{ x = fn.js('a') }", [
+    assertParse("objectLiteral", "{ x = fn.js('a') }", [
       ops.object,
       [
         "x",
@@ -456,12 +684,12 @@ describe("Origami parser", () => {
         ],
       ],
     ]);
-    assertParse("object", "{ a: 1, ...b }", [
+    assertParse("objectLiteral", "{ a: 1, ...b }", [
       ops.merge,
       [ops.object, ["a", [ops.literal, 1]]],
-      [ops.scope, "b"],
+      [undetermined, "b"],
     ]);
-    assertParse("object", "{ (a): 1 }", [
+    assertParse("objectLiteral", "{ (a): 1 }", [
       ops.object,
       ["(a)", [ops.literal, 1]],
     ]);
@@ -523,40 +751,9 @@ describe("Origami parser", () => {
     assertParse("objectPublicKey", "foo\\ bar", "foo bar", false);
   });
 
-  test("parameterizedLambda", () => {
-    assertParse("parameterizedLambda", "() => foo", [
-      ops.lambda,
-      [],
-      [ops.scope, "foo"],
-    ]);
-    assertParse("parameterizedLambda", "(a, b, c) ⇒ fn(a, b, c)", [
-      ops.lambda,
-      ["a", "b", "c"],
-      [
-        [ops.builtin, "fn"],
-        [ops.scope, "a"],
-        [ops.scope, "b"],
-        [ops.scope, "c"],
-      ],
-    ]);
-    assertParse("parameterizedLambda", "(a) => (b) => fn(a, b)", [
-      ops.lambda,
-      ["a"],
-      [
-        ops.lambda,
-        ["b"],
-        [
-          [ops.builtin, "fn"],
-          [ops.scope, "a"],
-          [ops.scope, "b"],
-        ],
-      ],
-    ]);
-  });
-
-  test("parensArgs", () => {
-    assertParse("parensArgs", "()", [undefined]);
-    assertParse("parensArgs", "(a, b, c)", [
+  test("parenthesesArguments", () => {
+    assertParse("parenthesesArguments", "()", [undefined]);
+    assertParse("parenthesesArguments", "(a, b, c)", [
       [ops.scope, "a"],
       [ops.scope, "b"],
       [ops.scope, "c"],
@@ -564,47 +761,63 @@ describe("Origami parser", () => {
   });
 
   test("path", () => {
-    assertParse("path", "tree/", [[ops.literal, "tree/"]]);
-    assertParse("path", "month/12", [
+    assertParse("path", "/tree/", [[ops.literal, "tree/"]]);
+    assertParse("path", "/month/12", [
       [ops.literal, "month/"],
       [ops.literal, "12"],
     ]);
-    assertParse("path", "tree/foo/bar", [
+    assertParse("path", "/tree/foo/bar", [
       [ops.literal, "tree/"],
       [ops.literal, "foo/"],
       [ops.literal, "bar"],
     ]);
-    assertParse("path", "a///b", [
+    assertParse("path", "/a///b", [
       [ops.literal, "a/"],
       [ops.literal, "b"],
     ]);
   });
 
-  test("pipeline", () => {
-    assertParse("pipeline", "foo", [ops.scope, "foo"]);
-    assertParse("pipeline", "a -> b", [
+  test("pathArguments", () => {
+    assertParse("pathArguments", "/", [ops.traverse]);
+    assertParse("pathArguments", "/tree", [
+      ops.traverse,
+      [ops.literal, "tree"],
+    ]);
+    assertParse("pathArguments", "/tree/", [
+      ops.traverse,
+      [ops.literal, "tree/"],
+    ]);
+  });
+
+  test("pipelineExpression", () => {
+    assertParse("pipelineExpression", "foo", [ops.scope, "foo"]);
+    assertParse("pipelineExpression", "a -> b", [
       [ops.builtin, "b"],
       [ops.scope, "a"],
     ]);
-    assertParse("pipeline", "input → one.js → two.js", [
+    assertParse("pipelineExpression", "input → one.js → two.js", [
       [ops.scope, "two.js"],
       [
         [ops.scope, "one.js"],
         [ops.scope, "input"],
       ],
     ]);
-    assertParse("pipeline", "fn a -> b", [
+    assertParse("pipelineExpression", "fn a -> b", [
       [ops.builtin, "b"],
       [
         [ops.builtin, "fn"],
-        [ops.scope, "a"],
+        [undetermined, "a"],
       ],
     ]);
   });
 
-  test("pipelineStep", () => {
-    assertParse("pipelineStep", "foo", [ops.builtin, "foo"]);
-    assertParse("pipelineStep", "=_", [ops.lambda, ["_"], [ops.scope, "_"]]);
+  test("primary", () => {
+    assertParse("primary", "foo.js", [ops.scope, "foo.js"]);
+    assertParse("primary", "[1, 2]", [
+      ops.array,
+      [ops.literal, 1],
+      [ops.literal, 2],
+    ]);
   });
 
   test("program", () => {
@@ -618,23 +831,114 @@ describe("Origami parser", () => {
     );
   });
 
+  test("protocolExpression", () => {
+    assertParse("protocolExpression", "foo://bar", [
+      [ops.builtin, "foo:"],
+      [ops.literal, "bar"],
+    ]);
+    assertParse("protocolExpression", "http://example.com", [
+      [ops.builtin, "http:"],
+      [ops.literal, "example.com"],
+    ]);
+    assertParse("protocolExpression", "https://example.com/about/", [
+      [ops.builtin, "https:"],
+      [ops.literal, "example.com/"],
+      [ops.literal, "about/"],
+    ]);
+    assertParse("protocolExpression", "https://example.com/about/index.html", [
+      [ops.builtin, "https:"],
+      [ops.literal, "example.com/"],
+      [ops.literal, "about/"],
+      [ops.literal, "index.html"],
+    ]);
+    assertParse("protocolExpression", "http://localhost:5000/foo", [
+      [ops.builtin, "http:"],
+      [ops.literal, "localhost:5000/"],
+      [ops.literal, "foo"],
+    ]);
+  });
+
+  test("qualifiedReference", () => {
+    assertParse("qualifiedReference", "js:Date", [
+      [ops.builtin, "js:"],
+      [ops.literal, "Date"],
+    ]);
+  });
+
+  test("relationalExpression", () => {
+    assertParse("relationalExpression", "1 < 2", [
+      ops.lessThan,
+      [ops.literal, 1],
+      [ops.literal, 2],
+    ]);
+    assertParse("relationalExpression", "3 > 4", [
+      ops.greaterThan,
+      [ops.literal, 3],
+      [ops.literal, 4],
+    ]);
+    assertParse("relationalExpression", "5 <= 6", [
+      ops.lessThanOrEqual,
+      [ops.literal, 5],
+      [ops.literal, 6],
+    ]);
+    assertParse("relationalExpression", "7 >= 8", [
+      ops.greaterThanOrEqual,
+      [ops.literal, 7],
+      [ops.literal, 8],
+    ]);
+  });
+
+  test("rootDirectory", () => {
+    assertParse("rootDirectory", "/", [ops.rootDirectory]);
+  });
+
   test("scopeReference", () => {
-    assertParse("scopeReference", "x", [ops.scope, "x"]);
+    assertParse("scopeReference", "keys", [undetermined, "keys"]);
+    assertParse("scopeReference", "greet.js", [ops.scope, "greet.js"]);
+    // scopeReference checks whether a slash follows; hard to test in isolation
+    // assertParse("scopeReference", "markdown/", [ops.scope, "markdown"]);
   });
 
-  test("scopeTraverse", () => {
-    assertParse("scopeTraverse", "tree/", [ops.traverse, [ops.scope, "tree/"]]);
-    assertParse("scopeTraverse", "tree/foo/bar", [
-      ops.traverse,
-      [ops.scope, "tree/"],
-      [ops.literal, "foo/"],
-      [ops.literal, "bar"],
+  test("shiftExpression", () => {
+    assertParse("shiftExpression", "1 << 2", [
+      ops.shiftLeft,
+      [ops.literal, 1],
+      [ops.literal, 2],
     ]);
-    assertParse("scopeTraverse", "tree/foo/bar/", [
-      ops.traverse,
-      [ops.scope, "tree/"],
-      [ops.literal, "foo/"],
-      [ops.literal, "bar/"],
+    assertParse("shiftExpression", "3 >> 4", [
+      ops.shiftRightSigned,
+      [ops.literal, 3],
+      [ops.literal, 4],
+    ]);
+    assertParse("shiftExpression", "5 >>> 6", [
+      ops.shiftRightUnsigned,
+      [ops.literal, 5],
+      [ops.literal, 6],
+    ]);
+  });
+
+  test("shorthandFunction", () => {
+    assertParse("shorthandFunction", "=message", [
+      ops.lambda,
+      ["_"],
+      [undetermined, "message"],
+    ]);
+    assertParse("shorthandFunction", "=`Hello, ${name}.`", [
+      ops.lambda,
+      ["_"],
+      [
+        ops.template,
+        [ops.literal, ["Hello, ", "."]],
+        [ops.concat, [ops.scope, "name"]],
+      ],
+    ]);
+    assertParse("shorthandFunction", "=indent`hello`", [
+      ops.lambda,
+      ["_"],
+      [
+        [ops.builtin, "indent"],
+        [ops.literal, ["hello"]],
+      ],
     ]);
   });
 
@@ -643,32 +947,21 @@ describe("Origami parser", () => {
   });
 
   test("spread", () => {
-    assertParse("spread", "...a", [ops.spread, [ops.scope, "a"]]);
-    assertParse("spread", "…a", [ops.spread, [ops.scope, "a"]]);
-  });
-
-  test("string", () => {
-    assertParse("string", '"foo"', [ops.literal, "foo"]);
-    assertParse("string", "'bar'", [ops.literal, "bar"]);
-    assertParse("string", '"foo bar"', [ops.literal, "foo bar"]);
-    assertParse("string", "'bar baz'", [ops.literal, "bar baz"]);
-    assertParse("string", `"foo\\"s bar"`, [ops.literal, `foo"s bar`]);
-    assertParse("string", `'bar\\'s baz'`, [ops.literal, `bar's baz`]);
-    assertParse("string", `«string»`, [ops.literal, "string"]);
-    assertParse("string", `"\\0\\b\\f\\n\\r\\t\\v"`, [
-      ops.literal,
-      "\0\b\f\n\r\t\v",
-    ]);
+    assertParse("spread", "...a", [ops.spread, [undetermined, "a"]]);
+    assertParse("spread", "…a", [ops.spread, [undetermined, "a"]]);
   });
 
-  test("taggedTemplate", () => {
-    assertParse("taggedTemplate", "indent`hello`", [
-      [ops.builtin, "indent"],
-      [ops.literal, ["hello"]],
-    ]);
-    assertParse("taggedTemplate", "fn.js`Hello, world.`", [
-      [ops.scope, "fn.js"],
-      [ops.literal, ["Hello, world."]],
+  test("stringLiteral", () => {
+    assertParse("stringLiteral", '"foo"', [ops.literal, "foo"]);
+    assertParse("stringLiteral", "'bar'", [ops.literal, "bar"]);
+    assertParse("stringLiteral", '"foo bar"', [ops.literal, "foo bar"]);
+    assertParse("stringLiteral", "'bar baz'", [ops.literal, "bar baz"]);
+    assertParse("stringLiteral", `"foo\\"s bar"`, [ops.literal, `foo"s bar`]);
+    assertParse("stringLiteral", `'bar\\'s baz'`, [ops.literal, `bar's baz`]);
+    assertParse("stringLiteral", `«string»`, [ops.literal, "string"]);
+    assertParse("stringLiteral", `"\\0\\b\\f\\n\\r\\t\\v"`, [
+      ops.literal,
+      "\0\b\f\n\r\t\v",
     ]);
   });
 
@@ -741,80 +1034,16 @@ describe("Origami parser", () => {
       false
     );
   });
-});
 
-test("value", () => {
-  assertParse("value", "obj.json", [ops.scope, "obj.json"]);
-  assertParse("value", "(fn a, b, c)", [
-    [ops.builtin, "fn"],
-    [ops.scope, "a"],
-    [ops.scope, "b"],
-    [ops.scope, "c"],
-  ]);
-  assertParse("value", "foo.bar('hello', 'world')", [
-    [ops.scope, "foo.bar"],
-    [ops.literal, "hello"],
-    [ops.literal, "world"],
-  ]);
-  assertParse("value", "(key)('a')", [
-    [ops.scope, "key"],
-    [ops.literal, "a"],
-  ]);
-  assertParse("value", "1", [ops.literal, 1]);
-  assertParse("value", "{ a: 1, b: 2 }", [
-    ops.object,
-    ["a", [ops.literal, 1]],
-    ["b", [ops.literal, 2]],
-  ]);
-  assertParse("value", "serve { index.html: 'hello' }", [
-    [ops.builtin, "serve"],
-    [ops.object, ["index.html", [ops.literal, "hello"]]],
-  ]);
-  assertParse("value", "fn =`x`", [
-    [ops.builtin, "fn"],
-    [ops.lambda, ["_"], [ops.template, [ops.literal, ["x"]]]],
-  ]);
-  assertParse("value", "copy app.js(formulas), files:snapshot", [
-    [ops.builtin, "copy"],
-    [
-      [ops.scope, "app.js"],
-      [ops.scope, "formulas"],
-    ],
-    [
-      [ops.builtin, "files:"],
-      [ops.literal, "snapshot"],
-    ],
-  ]);
-  assertParse("value", "map =`<li>${_}</li>`", [
-    [ops.builtin, "map"],
-    [
-      ops.lambda,
-      ["_"],
-      [
-        ops.template,
-        [ops.literal, ["<li>", "</li>"]],
-        [ops.concat, [ops.scope, "_"]],
-      ],
-    ],
-  ]);
-  assertParse("value", `"https://example.com"`, [
-    ops.literal,
-    "https://example.com",
-  ]);
-  assertParse("value", "tag`Hello, ${name}!`", [
-    [ops.builtin, "tag"],
-    [ops.literal, ["Hello, ", "!"]],
-    [ops.concat, [ops.scope, "name"]],
-  ]);
-  assertParse("value", "(post, slug) => fn.js(post, slug)", [
-    ops.lambda,
-    ["post", "slug"],
-    [
-      [ops.scope, "fn.js"],
-      [ops.scope, "post"],
-      [ops.scope, "slug"],
-    ],
-  ]);
+  test("unaryExpression", () => {
+    assertParse("unaryExpression", "!true", [
+      ops.logicalNot,
+      [undetermined, "true"],
+    ]);
+    assertParse("unaryExpression", "+1", [ops.unaryPlus, [ops.literal, 1]]);
+    assertParse("unaryExpression", "-2", [ops.unaryMinus, [ops.literal, 2]]);
+    assertParse("unaryExpression", "~3", [ops.bitwiseNot, [ops.literal, 3]]);
+  });
 });
 
 function assertParse(startRule, source, expected, checkLocation = true) {