@fraczak/k 7.1.0 → 8.0.0

package/tests/test-named-patterns.mjs

@@ -0,0 +1,189 @@
+// tests/test-named-patterns.mjs
+// Comprehensive test suite for named patterns and type schemes.
+
+import assert from "node:assert/strict";
+import k from "../index.mjs";
+import { Value } from "../Value.mjs";
+
+console.log("==> Running Named Patterns Test Suite");
+
+// Test 1: 0-arity pattern and composite product
+console.log("--> Test 1: 0-arity pattern (bit[]) and product (byte[])");
+{
+  const script = `
+    bit[] = < {}0, {}1 >;
+    byte[] = {
+      bit[] b0, bit[] b1, bit[] b2, bit[] b3,
+      bit[] b4, bit[] b5, bit[] b6, bit[] b7
+    };
+
+    is_byte = ? byte[];
+
+    sample = {
+      {}|0 b0, {}|1 b1, {}|0 b2, {}|1 b3,
+      {}|0 b4, {}|1 b5, {}|0 b6, {}|1 b7
+    };
+
+    sample is_byte
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.type, "{}");
+  assert.equal(out.product.b0.tag, "0");
+  assert.equal(out.product.b1.tag, "1");
+  console.log("    Passed: 0-arity patterns and composition.");
+}
+
+// Test 2: Parameterized list pattern
+console.log("--> Test 2: Parameterized pattern (list[X])");
+{
+  const script = `
+    bit[] = < {}0, {}1 >;
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+
+    is_bit_list = ? list[bit[]];
+
+    empty = {}|nil is_bit_list;
+    one = { {}|1 car, {}|nil cdr }|cons is_bit_list;
+    two = {
+      {}|0 car,
+      { {}|1 car, {}|nil cdr }|cons cdr
+    }|cons is_bit_list;
+
+    { empty empty, one one, two two }
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.product.empty.tag, "nil");
+  assert.equal(out.product.one.tag, "cons");
+  assert.equal(out.product.one.value.product.car.tag, "1");
+  assert.equal(out.product.two.tag, "cons");
+  assert.equal(out.product.two.value.product.car.tag, "0");
+  console.log("    Passed: Parameterized list pattern.");
+}
+
+// Test 3: Multi-parameter templates and composition
+console.log("--> Test 3: Multi-parameter templates (pair, dict)");
+{
+  const script = `
+    bit[] = < {}0, {}1 >;
+    pair[A, B] = { A key, B val };
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+    dict[K, V] = list[pair[K, V]];
+
+    is_dict = ? dict[bit[], bit[]];
+
+    entry = { {}|0 key, {}|1 val };
+    d = { entry car, {}|nil cdr }|cons is_dict;
+
+    d
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.tag, "cons");
+  assert.equal(out.value.product.car.product.key.tag, "0");
+  assert.equal(out.value.product.car.product.val.tag, "1");
+  console.log("    Passed: Multi-parameter template composition.");
+}
+
+// Test 4: Existential internal variables (type unification across fields)
+console.log("--> Test 4: Existential variables (same_pair[])");
+{
+  const scriptOk = `
+    same_pair[] = { T first, T second };
+    check = ? same_pair[];
+    { {}|0 first, {}|1 second } check
+  `;
+  const fnOk = k.compile(scriptOk);
+  const outOk = fnOk(Value.product({}));
+  assert.equal(outOk.product.first.tag, "0");
+  assert.equal(outOk.product.second.tag, "1");
+
+  const scriptBad = `
+    same_pair[] = { T first, T second };
+    check = ? same_pair[];
+    { {} first, {}|0 second } check
+  `;
+  assert.throws(
+    () => k.compile(scriptBad),
+    /Cannot unify/
+  );
+  console.log("    Passed: Existential variables unified across fields.");
+}
+
+// Test 5: Recursive tree with internal knot and list
+console.log("--> Test 5: Recursive tree with knot T (tree[X])");
+{
+  const script = `
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+    tree[X] = < {}nil, { X val, list[T] children } node > = T;
+
+    bit[] = < {}0, {}1 >;
+    is_tree = ? tree[bit[]];
+
+    leaf = { {}|1 val, {}|nil children }|node is_tree;
+    root = {
+      {}|0 val,
+      { leaf car, {}|nil cdr }|cons children
+    }|node is_tree;
+
+    { leaf leaf, root root }
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.product.leaf.tag, "node");
+  assert.equal(out.product.leaf.value.product.val.tag, "1");
+  assert.equal(out.product.root.tag, "node");
+  assert.equal(out.product.root.value.product.val.tag, "0");
+  console.log("    Passed: Recursive tree template with list port.");
+}
+
+// Test 6: Polymorphic relation with shared type variable
+console.log("--> Test 6: Polymorphic relation ({ X car, list[X] cdr })");
+{
+  const script = `
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+    head = ? { X car, list[X] cdr } .car;
+
+    bit[] = < {}0, {}1 >;
+    h1 = { {}|1 car, {}|nil cdr } head;
+
+    h1
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.tag, "1");
+  console.log("    Passed: Polymorphic relation head with list[X].");
+}
+
+// Test 7: Error handling for templates
+console.log("--> Test 7: Error handling (unknown, arity, cycles, dupes)");
+{
+  assert.throws(
+    () => k.compile("check = ? missing[]; ()"),
+    /Unknown pattern template 'missing\[\]'/
+  );
+
+  assert.throws(
+    () => k.compile("list[X] = {}; check = ? list[]; ()"),
+    /Pattern 'list' expects 1 argument, got 0/
+  );
+
+  assert.throws(
+    () => k.compile("pair[A, B] = {}; check = ? pair[{}]; ()"),
+    /Pattern 'pair' expects 2 arguments, got 1/
+  );
+
+  assert.throws(
+    () => k.compile("a[] = b[]; b[] = a[]; check = ? a[]; ()"),
+    /Cyclic pattern template dependency detected/
+  );
+
+  assert.throws(
+    () => k.compile("dupe[X, X] = {}; ()"),
+    /Duplicate parameter 'X' in pattern 'dupe'/
+  );
+  console.log("    Passed: Error conditions correctly handled.");
+}
+
+console.log("==> All Named Patterns Tests Passed Successfully!");

package/tests/test-repl-html.mjs

@@ -140,6 +140,12 @@ if (chromiumBin) {
     const expectedFiles = [
       "arithmetics.k",
       "core.k",
+      "djson-btrie.k",
+      "djson-btrie.mjs",
+      "djson-ptrie.k",
+      "djson-ptrie.mjs",
+      "djson.k",
+      "djson.mjs",
       "ieee.k",
       "ieee.mjs",
       "int.mjs",
@@ -521,9 +527,9 @@ if (chromiumBin) {
       const v4Collapsed = v4 ? !v4.open : false;
 
       // Click Expand All
-      const actionBtns = lastEntry.querySelectorAll(".k-btn-action");
-      const expandBtn = actionBtns[0];
-      const collapseBtn = actionBtns[1];
+      const toolbarActionBtns = lastEntry.querySelectorAll(".k-output-toolbar .k-btn-action");
+      const expandBtn = toolbarActionBtns[0];
+      const collapseBtn = toolbarActionBtns[1];
 
       expandBtn.click();
       const allOpenAfterExpand = v4.open;
@@ -535,13 +541,48 @@ if (chromiumBin) {
       );
       const v4CollapsedAgain = newV4 ? !newV4.open : false;
 
+      // Verify Copy buttons on Value and Pattern section headers
+      const patSection = lastEntry.querySelector(".k-tree-pat-section");
+      const copyValBtn = valSection?.querySelector("summary.k-tree-section-summary > .k-btn-copy-value");
+      const copyPatBtn = patSection?.querySelector("summary.k-tree-section-summary > .k-btn-copy-pattern");
+
+      const copiedTexts = [];
+      const origWriteText = navigator.clipboard?.writeText;
+      if (navigator.clipboard) {
+        navigator.clipboard.writeText = async (txt) => { copiedTexts.push(txt); };
+      } else {
+        Object.defineProperty(navigator, "clipboard", {
+          value: { writeText: async (txt) => { copiedTexts.push(txt); } },
+          configurable: true
+        });
+      }
+
+      const valOpenBefore = valSection?.open;
+      copyValBtn?.click();
+      const valOpenAfter = valSection?.open;
+
+      const patOpenBefore = patSection?.open;
+      copyPatBtn?.click();
+      const patOpenAfter = patSection?.open;
+
+      if (origWriteText && navigator.clipboard) {
+        navigator.clipboard.writeText = origWriteText;
+      }
+
       return {
         v1Open,
         v2Open,
         v3Open,
         v4Collapsed,
         allOpenAfterExpand,
-        v4CollapsedAgain
+        v4CollapsedAgain,
+        toolbarBtnCount: toolbarActionBtns.length,
+        hasCopyValBtn: !!copyValBtn,
+        hasCopyPatBtn: !!copyPatBtn,
+        valDidNotToggle: valOpenBefore === valOpenAfter,
+        patDidNotToggle: patOpenBefore === patOpenAfter,
+        copiedValText: copiedTexts[0] || "",
+        copiedPatText: copiedTexts[1] || ""
       };
     })()`);
 
@@ -551,6 +592,13 @@ if (chromiumBin) {
     assert.strictEqual(variantDepthAndActionsCheck.v4Collapsed, true, "Variant level 4 must be collapsed by default");
     assert.strictEqual(variantDepthAndActionsCheck.allOpenAfterExpand, true, "Expand button should expand collapsed nodes");
     assert.strictEqual(variantDepthAndActionsCheck.v4CollapsedAgain, true, "Collapse button should reset deeper nodes to collapsed");
+    assert.strictEqual(variantDepthAndActionsCheck.toolbarBtnCount, 2, "Toolbar action group should only have Expand and Collapse buttons");
+    assert.strictEqual(variantDepthAndActionsCheck.hasCopyValBtn, true, "Value section summary should have Copy button");
+    assert.strictEqual(variantDepthAndActionsCheck.hasCopyPatBtn, true, "Pattern section summary should have Copy button");
+    assert.strictEqual(variantDepthAndActionsCheck.valDidNotToggle, true, "Clicking Value Copy button should not toggle Value details");
+    assert.strictEqual(variantDepthAndActionsCheck.patDidNotToggle, true, "Clicking Pattern Copy button should not toggle Pattern details");
+    assert.strictEqual(variantDepthAndActionsCheck.copiedValText, "{}|_|0|1|0|1", "Value Copy button should copy K value definition");
+    assert(variantDepthAndActionsCheck.copiedPatText.startsWith("?<"), `Pattern Copy button should copy K pattern filter definition, got: ${variantDepthAndActionsCheck.copiedPatText}`);
 
     // 4. Verify shortened welcome banner
     const bannerCheck = await evaluateAsync(`(() => {

package/tests/test-repl.mjs

@@ -226,6 +226,18 @@ output = await evaluateInput(':input json.mjs {"left":true,"right":false}', json
 assert.match(output[0], /json\.mjs: \{"left":true,"right":false\}/);
 assert.equal(promptForState(jsonState), "> ");
 
+// Test djson.mjs in repl
+const djsonState = createState();
+output = await evaluateInput(":codec load ./codecs/djson.mjs", djsonState);
+assert.match(output[0], /^loaded codec djson\.mjs/);
+completions = completeInput(":input dj", djsonState)[0];
+assert(completions.includes(":input djson.mjs"));
+output = await evaluateInput(
+  ':input djson.mjs {"msg":"hello","values":[1,2]}',
+  djsonState
+);
+assert.match(output[0], /djson\.mjs: \{"msg":"hello","values":\[1,2\]\}/);
+
 const replPath = fileURLToPath(new URL("../repl.mjs", import.meta.url));
 try {
   fs.rmSync(symlinkPath, { force: true });
@@ -548,6 +560,217 @@ output = await evaluateInput("len", wasmListState);
 assert.match(output[0], /int\.mjs:\s*3/);
 assert.match(output[1], /\(wasm\)/);
 
+// Verify :limit command and bounded printing
+const limitState = createState({ engine: "wasm" });
+output = await evaluateInput(":limit", limitState);
+assert.equal(output[0], "Current output limit: none");
+
+output = await evaluateInput(":limit 40", limitState);
+assert.equal(output[0], "output limit set to 40");
+
+output = await evaluateInput(":limit", limitState);
+assert.equal(output[0], "Current output limit: 40");
+
+output = await evaluateInput(":load Examples/arithmetics.k", limitState);
+output = await evaluateInput("{ 10 int x, 5 int y } plus", limitState);
+assert(output[0].includes("..."));
+assert(output[0].length <= 80);
+
+output = await evaluateInput(":limit none", limitState);
+assert.equal(output[0], "output limit disabled");
+output = await evaluateInput(":limit", limitState);
+assert.equal(output[0], "Current output limit: none");
+
+// Verify Examples/djson.k (json?, dot, has_key?, keys, values, remove, put)
+const jsonKState = createState({ engine: "wasm" });
+output = await evaluateInput(":load Examples/djson.k", jsonKState);
+assert.equal(output[0], "loaded Examples/djson.k");
+await evaluateInput(":codec load codecs/djson.mjs", jsonKState);
+await evaluateInput(
+  ':input djson.mjs {"name":"Alice","age":30,"active":true}',
+  jsonKState
+);
+output = await evaluateInput(
+  "{/object cdr car .key key, /object object} dot",
+  jsonKState
+);
+assert.match(output[0], /djson\.mjs: 30/);
+
+await evaluateInput(
+  ':input djson.mjs {"name":"Alice","age":30}',
+  jsonKState
+);
+output = await evaluateInput(
+  "{/object car .key key, /object object} remove object",
+  jsonKState
+);
+assert.match(output[0], /djson\.mjs: \{"name":"Alice"\}/);
+
+// Verify Examples/djson-btrie.k (json?, dot, nth, put, remove)
+const btrieState = createState({ engine: "wasm" });
+output = await evaluateInput(":load Examples/djson-btrie.k", btrieState);
+assert.equal(output[0], "loaded Examples/djson-btrie.k");
+await evaluateInput(":codec load codecs/djson-btrie.mjs", btrieState);
+await evaluateInput(
+  ':input djson-btrie.mjs ["age", {"name":"Alice","age":30}]',
+  btrieState
+);
+output = await evaluateInput(
+  "{{0 index, /list list} nth /string key, " +
+    "{1 index, /list list} nth /object object} dot",
+  btrieState
+);
+assert.match(output[0], /djson-btrie\.mjs: 30/);
+
+await evaluateInput(
+  ':input djson-btrie.mjs ["age", {"name":"Alice","age":30}]',
+  btrieState
+);
+output = await evaluateInput(
+  "{{0 index, /list list} nth /string key, " +
+    "{1 index, /list list} nth /object object} remove object",
+  btrieState
+);
+assert.match(output[0], /djson-btrie\.mjs: \{"name":"Alice"\}/);
+
+// Verify Examples/djson-ptrie.k (json?, dot, nth, list_size, obj_size)
+const ptrieState = createState({ engine: "wasm" });
+output = await evaluateInput(":load Examples/djson-ptrie.k", ptrieState);
+assert.equal(output[0], "loaded Examples/djson-ptrie.k");
+await evaluateInput(":codec load codecs/djson-ptrie.mjs", ptrieState);
+await evaluateInput(
+  ':input djson-ptrie.mjs ["age", {"name":"Alice","age":30}]',
+  ptrieState
+);
+output = await evaluateInput(
+  "{{0 index, /list list} nth /string key, " +
+    "{1 index, /list list} nth /object object} dot",
+  ptrieState
+);
+assert.match(output[0], /djson-ptrie\.mjs: 30/);
+
+// Verify named pattern persistence, listing, display, and tab completion
+const patState = createState({ engine: "wasm" });
+
+output = await evaluateInput(":patterns", patState);
+assert.equal(output[0], "(none)");
+output = await evaluateInput(":pats", patState);
+assert.equal(output[0], "(none)");
+
+output = await evaluateInput("bit[] = < {} 0, {} 1 >;", patState);
+assert.match(output[0], /\/\* comp:/);
+
+output = await evaluateInput(":patterns", patState);
+assert.equal(output[0], "bit[]");
+output = await evaluateInput(":pats", patState);
+assert.equal(output[0], "bit[]");
+
+output = await evaluateInput(":pattern bit", patState);
+assert.equal(
+  output[0],
+  "bit[] = <{} 0, {} 1>;  -- " +
+    "@MjusyRWZnVj8TR4BhFCCcMRrQbdKp9gPtC29LT9nZvjg"
+);
+output = await evaluateInput(":pattern bit[]", patState);
+assert.equal(
+  output[0],
+  "bit[] = <{} 0, {} 1>;  -- " +
+    "@MjusyRWZnVj8TR4BhFCCcMRrQbdKp9gPtC29LT9nZvjg"
+);
+output = await evaluateInput(":pat bit", patState);
+assert.equal(
+  output[0],
+  "bit[] = <{} 0, {} 1>;  -- " +
+    "@MjusyRWZnVj8TR4BhFCCcMRrQbdKp9gPtC29LT9nZvjg"
+);
+output = await evaluateInput(
+  ":pattern @MjusyRWZnVj8TR4BhFCCcMRrQbdKp9gPtC29LT9nZvjg",
+  patState
+);
+assert.equal(
+  output[0],
+  "bit[] = <{} 0, {} 1>;  -- " +
+    "@MjusyRWZnVj8TR4BhFCCcMRrQbdKp9gPtC29LT9nZvjg"
+);
+
+await assert.rejects(
+  () => evaluateInput(":pattern unknown", patState),
+  /Unknown pattern 'unknown'/
+);
+await assert.rejects(
+  () => evaluateInput(":pattern", patState),
+  /:pattern requires a pattern name/
+);
+
+completions = completeInput(":pat", patState)[0];
+assert(completions.includes(":pattern"));
+assert(completions.includes(":patterns"));
+assert(completions.includes(":pat"));
+assert(completions.includes(":pats"));
+
+completions = completeInput(":pattern b", patState)[0];
+assert(completions.includes(":pattern bit"));
+completions = completeInput(":pat b", patState)[0];
+assert(completions.includes(":pat bit"));
+completions = completeInput(":pattern @Mjusy", patState)[0];
+assert(
+  completions.includes(
+    ":pattern @MjusyRWZnVj8TR4BhFCCcMRrQbdKp9gPtC29LT9nZvjg"
+  )
+);
+
+output = await evaluateInput("{} | 0 ? bit[]", patState);
+assert.match(output[0], /\{\}\|0/);
+
+output = await evaluateInput(
+  "pair[A, B] = { A first, B second };",
+  patState
+);
+output = await evaluateInput(":pattern pair", patState);
+assert.equal(
+  output[0],
+  "pair[A, B] = {A first, B second};  -- " +
+    "@KqTBNkznjWWwync2Mm94XjCez63neJBJtgYcJJEE5kEm"
+);
+
+output = await evaluateInput(":load Examples/list.k", patState);
+assert.equal(output[0], "loaded Examples/list.k");
+output = await evaluateInput(":patterns", patState);
+assert(output[0].includes("bit[]"));
+assert(output[0].includes("list[X]"));
+assert(output[0].includes("pair[A, B]"));
+
+output = await evaluateInput(":pattern list", patState);
+assert.equal(
+  output[0],
+  "list[X] = <{} nil, {X car, Y cdr} cons>=Y;  -- " +
+    "@JagVexzgseRr4rVZRmVpsMbr2AKXDjzZnz6Qnf8a9SNe"
+);
+
+output = await evaluateInput("{} | nil ? list[bit[]]", patState);
+assert.match(output[0], /\{\}\|nil/);
+
+const testKlibPath = path.join(tmpDir, "patterns-test.klib");
+output = await evaluateInput(`:klib ${testKlibPath}`, patState);
+assert.equal(output[0], `saved ${testKlibPath}`);
+
+const freshState = createState({ engine: "wasm" });
+output = await evaluateInput(`:load ${testKlibPath}`, freshState);
+assert.equal(output[0], `loaded ${testKlibPath}`);
+output = await evaluateInput(":patterns", freshState);
+assert(output[0].includes("bit[]"));
+assert(output[0].includes("pair[A, B]"));
+assert(output[0].includes("list[X]"));
+
+output = await evaluateInput(":pattern bit", freshState);
+assert.equal(
+  output[0],
+  "bit[] = <{} 0, {} 1>;  -- " +
+    "@MjusyRWZnVj8TR4BhFCCcMRrQbdKp9gPtC29LT9nZvjg"
+);
+output = await evaluateInput("{} | nil ? list[bit[]]", freshState);
+assert.match(output[0], /\{\}\|nil/);
+
 fs.rmSync(tmpDir, { recursive: true, force: true });
 fs.rmSync(symlinkPath, { force: true });
 console.log("OK");