@weborigami/language 0.0.40 → 0.0.41

package/src/compiler/parserHelpers.js

@@ -8,7 +8,11 @@ export function makeFunctionCall(target, chain) {
   // successively apply the top-level elements of that chain to build up the
   // function composition.
   for (const args of chain) {
-    value = [value, ...args];
+    if (args[0] === ops.traverse) {
+      value = [ops.traverse, value, ...args.slice(1)];
+    } else {
+      value = [value, ...args];
+    }
   }
   return value;
 }

package/src/runtime/evaluate.js

@@ -37,22 +37,30 @@ export default async function evaluate(code) {
     );
   }
 
-  // The head of the array is a tree or function, the rest are args or keys.
+  // The head of the array is a function or a tree; the rest are args or keys.
   let [fn, ...args] = evaluated;
 
   if (!fn) {
-    // The code wants to invoke something that's not in scope.
+    // The code wants to invoke something that's couldn't be found in scope.
     throw ReferenceError(
       `Couldn't find function or tree key: ${format(code[0])}`
     );
-  } else if (!(fn instanceof Object)) {
-    throw TypeError(`Can't invoke primitive value: ${format(code[0])}`);
-  } else if (!(fn instanceof Function) && typeof fn.unpack === "function") {
-    // The object has a unpack function; see if it returns a function.
-    const unpacked = await fn.unpack();
-    if (unpacked instanceof Function) {
-      fn = unpacked;
-    }
+  }
+
+  if (
+    !(fn instanceof Function || Tree.isAsyncTree(fn)) &&
+    typeof fn.unpack === "function"
+  ) {
+    // Unpack the object and use the result as the function or tree.
+    fn = await fn.unpack();
+  }
+
+  if (!Tree.isTreelike(fn)) {
+    throw TypeError(
+      `Expect to invoke a function or a tree but instead got: ${format(
+        code[0]
+      )}`
+    );
   }
 
   // Execute the function or traverse the tree.
@@ -60,10 +68,8 @@ export default async function evaluate(code) {
   try {
     result =
       fn instanceof Function
-        ? // Invoke the function
-          await fn.call(scope, ...args)
-        : // Traverse the tree.
-          await Tree.traverseOrThrow(fn, ...args);
+        ? await fn.call(scope, ...args) // Invoke the function
+        : await Tree.traverseOrThrow(fn, ...args); // Traverse the tree.
   } catch (/** @type {any} */ error) {
     const message = `Error triggered by Origami expression: ${format(code)}`;
     throw new Error(message, { cause: error });

package/src/runtime/expressionFunction.js

@@ -27,6 +27,7 @@ export function createExpressionFunction(code, name) {
  * expression.
  *
  * @param {any} obj
+ * @returns {obj is { code: Array }}
  */
 export function isExpressionFunction(obj) {
   return typeof obj === "function" && obj.code;

package/src/runtime/format.js

@@ -87,7 +87,8 @@ function formatName(name) {
 }
 
 function formatLambda(code) {
-  return `=${format(code[1])}`;
+  // TODO: named parameters
+  return `=${format(code[2])}`;
 }
 
 function formatScopeTraversal(code, implicitFunctionCall = false) {

package/src/runtime/ops.js

@@ -3,7 +3,7 @@
  * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
  */
 
-import { SiteTree } from "@weborigami/async-tree";
+import { SiteTree, Tree } from "@weborigami/async-tree";
 import FileLoadersTransform from "./FileLoadersTransform.js";
 import OrigamiFiles from "./OrigamiFiles.js";
 import Scope from "./Scope.js";
@@ -130,23 +130,51 @@ inherited.toString = () => "«ops.inherited»";
  *
  * @typedef {import("../../../language/src/compiler/code.js").Code} Code
  * @this {AsyncTree|null}
+ * @param {string[]} parameters
  * @param {Code} code
  */
-export function lambda(code) {
+export function lambda(parameters, code) {
   if (lambdaFnMap.has(code)) {
     return lambdaFnMap.get(code);
   }
+
+  // By default, the first input argument is named `_`.
+  parameters ??= ["_"];
+
   /** @this {AsyncTree|null} */
-  async function invoke(input) {
-    // Add ambients to scope.
-    const ambients = {
-      _: input,
-      "@recurse": invoke,
-    };
+  async function invoke(...args) {
+    // Add arguments and @recurse to scope.
+    const ambients = {};
+    for (const parameter of parameters) {
+      ambients[parameter] = args.shift();
+    }
+    ambients["@recurse"] = invoke;
     const scope = new Scope(ambients, this);
-    const result = await evaluate.call(scope, code);
+
+    let result = await evaluate.call(scope, code);
+
+    // Bind a function result to the scope so that it has access to the
+    // parameter values -- i.e., like a closure.
+    if (result instanceof Function) {
+      const resultCode = result.code;
+      result = result.bind(scope);
+      if (code) {
+        // Copy over Origami code
+        result.code = resultCode;
+      }
+    }
+
     return result;
   }
+
+  // We set the `length` property on the function so that Tree.traverseOrThrow()
+  // will correctly identify how many parameters it wants. This is unorthodox
+  // but doesn't appear to affect other behavior.
+  const fnLength = Object.keys(parameters).length;
+  Object.defineProperty(invoke, "length", {
+    value: fnLength,
+  });
+
   invoke.code = code;
   lambdaFnMap.set(code, invoke);
   return invoke;
@@ -172,6 +200,11 @@ export async function object(...entries) {
 }
 object.toString = () => "«ops.object»";
 
+/**
+ * Traverse a path of keys through a tree.
+ */
+export const traverse = Tree.traverseOrThrow;
+
 /**
  * Construct an tree. This is similar to ops.object but the values are turned
  * into functions rather than being immediately evaluated, and the result is an

package/test/compiler/parse.test.js

@@ -12,19 +12,6 @@ describe("Origami parser", () => {
     ]);
   });
 
-  test("argsChain", () => {
-    assertParse("argsChain", "(a)(b)(c)", [
-      [[ops.scope, "a"]],
-      [[ops.scope, "b"]],
-      [[ops.scope, "c"]],
-    ]);
-    assertParse("argsChain", "(a)/b(c)", [
-      [[ops.scope, "a"]],
-      ["b"],
-      [[ops.scope, "c"]],
-    ]);
-  });
-
   test("array", () => {
     assertParse("array", "[]", [ops.array]);
     assertParse("array", "[1, 2, 3]", [ops.array, 1, 2, 3]);
@@ -71,7 +58,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("expr", "fn =`x`", [
       [ops.scope, "fn"],
-      [ops.lambda, "x"],
+      [ops.lambda, null, "x"],
     ]);
     assertParse("expr", "copy app(formulas), files 'snapshot'", [
       [ops.scope, "copy"],
@@ -83,7 +70,7 @@ describe("Origami parser", () => {
     ]);
     assertParse("expr", "@map =`<li>{{_}}</li>`", [
       [ops.scope, "@map"],
-      [ops.lambda, [ops.concat, "<li>", [ops.scope, "_"], "</li>"]],
+      [ops.lambda, null, [ops.concat, "<li>", [ops.scope, "_"], "</li>"]],
     ]);
     assertParse("expr", `"https://example.com"`, "https://example.com");
   });
@@ -134,25 +121,32 @@ describe("Origami parser", () => {
       [ops.scope, "arg"],
     ]);
     assertParse("functionComposition", "fn()/key", [
+      ops.traverse,
       [[ops.scope, "fn"], undefined],
       "key",
     ]);
-    assertParse("functionComposition", "tree/", [[ops.scope, "tree"], ""]);
+    assertParse("functionComposition", "tree/", [
+      ops.traverse,
+      [ops.scope, "tree"],
+      "",
+    ]);
     assertParse("functionComposition", "tree/key", [
+      ops.traverse,
       [ops.scope, "tree"],
       "key",
     ]);
     assertParse("functionComposition", "tree/foo/bar", [
+      ops.traverse,
       [ops.scope, "tree"],
       "foo",
       "bar",
     ]);
     assertParse("functionComposition", "tree/key()", [
-      [[ops.scope, "tree"], "key"],
+      [ops.traverse, [ops.scope, "tree"], "key"],
       undefined,
     ]);
     assertParse("functionComposition", "fn()/key()", [
-      [[[ops.scope, "fn"], undefined], "key"],
+      [ops.traverse, [[ops.scope, "fn"], undefined], "key"],
       undefined,
     ]);
     assertParse("functionComposition", "(fn())('arg')", [
@@ -169,6 +163,7 @@ describe("Origami parser", () => {
       [ops.scope, "b"],
     ]);
     assertParse("functionComposition", "{ a: 1, b: 2}/b", [
+      ops.traverse,
       [ops.object, ["a", 1], ["b", 2]],
       "b",
     ]);
@@ -224,9 +219,14 @@ describe("Origami parser", () => {
   });
 
   test("lambda", () => {
-    assertParse("lambda", "=message", [ops.lambda, [ops.scope, "message"]]);
+    assertParse("lambda", "=message", [
+      ops.lambda,
+      null,
+      [ops.scope, "message"],
+    ]);
     assertParse("lambda", "=`Hello, {{name}}.`", [
       ops.lambda,
+      null,
       [ops.concat, "Hello, ", [ops.scope, "name"], "."],
     ]);
   });
@@ -280,6 +280,37 @@ describe("Origami parser", () => {
     assertParse("objectPropertyOrShorthand", "x: y", ["x", [ops.scope, "y"]]);
   });
 
+  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.scope, "fn"],
+        [ops.scope, "a"],
+        [ops.scope, "b"],
+        [ops.scope, "c"],
+      ],
+    ]);
+    assertParse("parameterizedLambda", "(a) => (b) => fn(a, b)", [
+      ops.lambda,
+      ["a"],
+      [
+        ops.lambda,
+        ["b"],
+        [
+          [ops.scope, "fn"],
+          [ops.scope, "a"],
+          [ops.scope, "b"],
+        ],
+      ],
+    ]);
+  });
+
   test("parensArgs", () => {
     assertParse("parensArgs", "()", [undefined]);
     assertParse("parensArgs", "(a, b, c)", [
@@ -327,10 +358,12 @@ describe("Origami parser", () => {
   test("templateDocument", () => {
     assertParse("templateDocument", "hello{{foo}}world", [
       ops.lambda,
+      null,
       [ops.concat, "hello", [ops.scope, "foo"], "world"],
     ]);
     assertParse("templateDocument", "Documents can contain ` backticks", [
       ops.lambda,
+      null,
       "Documents can contain ` backticks",
     ]);
   });
@@ -349,7 +382,7 @@ describe("Origami parser", () => {
       [
         [ops.scope, "map"],
         [ops.scope, "people"],
-        [ops.lambda, [ops.concat, [ops.scope, "name"]]],
+        [ops.lambda, null, [ops.concat, [ops.scope, "name"]]],
       ],
     ]);
   });

package/test/runtime/evaluate.test.js

@@ -43,6 +43,14 @@ describe("evaluate", () => {
     await evaluate.call(scope, code);
   });
 
+  test("evaluates a function with fixed number of arguments", async () => {
+    const fn = (x, y) => ({
+      c: `${x}${y}c`,
+    });
+    const code = [ops.traverse, fn, "a", "b", "c"];
+    assert.equal(await evaluate.call(null, code), "abc");
+  });
+
   test("if object in function position isn't a function, can unpack it", async () => {
     const fn = (...args) => args.join(",");
     const packed = {

package/test/runtime/format.test.js

@@ -45,7 +45,7 @@ describe("Origami language code formatter", () => {
   });
 
   test("lambda", () => {
-    const code = [ops.lambda, [ops.scope, "message"]];
+    const code = [ops.lambda, null, [ops.scope, "message"]];
     assert.equal(format(code), "=message");
   });
 

package/test/runtime/ops.test.js

@@ -27,7 +27,7 @@ describe("ops", () => {
       message: "Hello",
     });
 
-    const code = [ops.lambda, [ops.scope, "message"]];
+    const code = [ops.lambda, null, [ops.scope, "message"]];
 
     const fn = await evaluate.call(scope, code);
     const result = await fn.call(scope);
@@ -35,17 +35,30 @@ describe("ops", () => {
   });
 
   test("lambda adds input to scope as `_`", async () => {
-    const code = [ops.lambda, [ops.scope, "_"]];
+    const code = [ops.lambda, null, [ops.scope, "_"]];
     const fn = await evaluate.call(null, code);
     const result = await fn("Hello");
     assert.equal(result, "Hello");
   });
 
+  test("parameterized lambda adds input args to scope", async () => {
+    const code = [
+      ops.lambda,
+      ["a", "b"],
+      [ops.concat, [ops.scope, "b"], [ops.scope, "a"]],
+    ];
+    const fn = await evaluate.call(null, code);
+    const result = await fn("x", "y");
+    assert.equal(result, "yx");
+  });
+
   test("a lambda can reference itself with @recurse", async () => {
-    const code = [ops.lambda, [ops.scope, "@recurse"]];
+    const code = [ops.lambda, null, [ops.scope, "@recurse"]];
     const fn = await evaluate.call(null, code);
     const result = await fn();
-    assert.equal(result, fn);
+    // We're expecting the function to return itself, but testing recursion is
+    // messy. We just confirm that the result has the same code as the original.
+    assert.equal(result.code, fn.code);
   });
 
   test("can instantiate an object", async () => {