@weborigami/language 0.0.40 → 0.0.42

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 () => {

package/src/compiler/code.d.ts

@@ -1,3 +0,0 @@
-import type { Treelike } from "@weborigami/async-tree";
-
-type Code = [Treelike, ...any[]] | any;

package/src/runtime/format.js

@@ -1,126 +0,0 @@
-import { ops } from "./internal.js";
-
-export default function format(code, implicitFunctionCall = false) {
-  if (code === null) {
-    return "";
-  } else if (typeof code === "string") {
-    return `'${code}'`;
-  } else if (typeof code === "symbol") {
-    return `«${code.description}»`;
-  } else if (!(code instanceof Array)) {
-    return code;
-  } else {
-    switch (code[0]) {
-      case ops.assign:
-        return formatAssignment(code);
-
-      case ops.concat:
-        return formatTemplate(code);
-
-      case ops.lambda:
-        return formatLambda(code);
-
-      case ops.object:
-        return formatObject(code);
-
-      case ops.scope:
-        return formatScopeTraversal(code, implicitFunctionCall);
-
-      case ops.tree:
-        return formatTree(code);
-
-      default:
-        return code[0] instanceof Array
-          ? formatFunctionCall(code)
-          : "** Unknown Origami code **";
-    }
-  }
-}
-
-function formatArgument(arg) {
-  return typeof arg === "string" ? `'${arg}'` : format(arg);
-}
-
-function formatArguments(args) {
-  const allStrings = args.every((arg) => typeof arg === "string");
-  return allStrings
-    ? // Use tree traversal syntax.
-      formatSlashPath(args)
-    : // Use function invocation syntax.
-      formatArgumentsList(args);
-}
-
-function formatArgumentsList(args) {
-  const formatted = args.map((arg) => formatArgument(arg));
-  const list = formatted.join(", ");
-  return `(${list})`;
-}
-
-function formatAssignment(code) {
-  const [_, declaration, expression] = code;
-  return `${declaration} = ${format(expression)}`;
-}
-
-function formatFunctionCall(code) {
-  const [fn, ...args] = code;
-  let formattedFn = format(fn);
-  if (formattedFn.includes("/") || formattedFn.includes("(")) {
-    formattedFn = `(${formattedFn})`;
-  }
-  return `${formattedFn}${formatArguments(args)}`;
-}
-
-function formatObject(code) {
-  const [_, ...entries] = code;
-  const formatted = entries.map(([key, value]) => {
-    return value === null ? key : `${key}: ${format(value)}`;
-  });
-  return formatted ? `{ ${formatted.join(", ")} }` : "{}";
-}
-
-function formatName(name) {
-  return typeof name === "string"
-    ? name
-    : name instanceof Array
-    ? `(${format(name)})`
-    : format(name);
-}
-
-function formatLambda(code) {
-  return `=${format(code[1])}`;
-}
-
-function formatScopeTraversal(code, implicitFunctionCall = false) {
-  const operands = code.slice(1);
-  const name = formatName(operands[0]);
-  if (operands.length === 1) {
-    return implicitFunctionCall ? `${name}()` : name;
-  }
-
-  const args = formatArguments(operands.slice(1));
-  return `${name}${args}`;
-}
-
-function formatSlashPath(args) {
-  return "/" + args.join("/");
-}
-
-function formatTemplate(code) {
-  const args = code.slice(1);
-  const formatted = args.map((arg) =>
-    typeof arg === "string" ? arg : `{{${format(arg)}}}`
-  );
-  return `\`${formatted.join("")}\``;
-}
-
-function formatTree(code) {
-  const [_, ...entries] = code;
-  const formatted = entries.map(([key, value]) => {
-    const rhs =
-      typeof value === "function" && value.code !== undefined
-        ? value.code
-        : value;
-    return `${key} = ${format(rhs)}`;
-  });
-  return formatted ? `{ ${formatted.join(", ")} }` : "{}";
-}

package/test/runtime/format.test.js

@@ -1,66 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import format from "../../src/runtime/format.js";
-import * as ops from "../../src/runtime/ops.js";
-
-describe("Origami language code formatter", () => {
-  test("assignment", () => {
-    const code = [ops.assign, "foo", [ops.scope, "bar"]];
-    assert.equal(format(code), "foo = bar");
-  });
-
-  test("scope reference", () => {
-    const code = [ops.scope, "foo"];
-    assert.equal(format(code), "foo");
-  });
-
-  test("implicit function call", () => {
-    const code = [ops.scope, "foo"];
-    assert.equal(format(code, true), "foo()");
-  });
-
-  test("function call", () => {
-    const code = [[ops.scope, "foo"], undefined];
-    assert.equal(format(code, true), "foo()");
-  });
-
-  test("tree traversal with string args", () => {
-    const code = [[ops.scope, "a"], "b", "c"];
-    assert.equal(format(code), "a/b/c");
-  });
-
-  test("tree traversal with numeric and string args", () => {
-    const code = [ops.scope, "fn", "x", 1, 2];
-    assert.equal(format(code), "fn('x', 1, 2)");
-  });
-
-  test("tree traversal with function arg and string arg", () => {
-    const code = [ops.scope, "fn", [ops.scope, "foo"], "bar"];
-    assert.equal(format(code), "fn(foo, 'bar')");
-  });
-
-  test("function composition", () => {
-    const code = [[[ops.scope, "fn"], "a"], "b"];
-    assert.equal(format(code), "(fn/a)/b");
-  });
-
-  test("lambda", () => {
-    const code = [ops.lambda, [ops.scope, "message"]];
-    assert.equal(format(code), "=message");
-  });
-
-  test("object", () => {
-    const code = [ops.object, ["a", "Hello"], ["b", "Goodbye"]];
-    assert.equal(format(code), "{ a: 'Hello', b: 'Goodbye' }");
-  });
-
-  test("template", () => {
-    const code = [ops.concat, "Hello, ", [ops.scope, "name"], "."];
-    assert.equal(format(code), "`Hello, {{name}}.`");
-  });
-
-  test("tree", () => {
-    const code = [ops.tree, ["x", [[ops.scope, "fn"], undefined]]];
-    assert.equal(format(code), "{ x = fn() }");
-  });
-});