@fraczak/k 6.2.1 → 6.2.2

package/codecs/runtime/codec.mjs

@@ -480,67 +480,89 @@ function refinePatternForValue(pattern, value) {
   }
 
   function collect(patternNodeId, currentValue) {
-    const patternNode = base.nodes[patternNodeId];
-    if (!patternNode) {
-      throw new Error(`Unknown pattern node ${patternNodeId}`);
-    }
-    pushOccurrence(patternNodeId, currentValue);
+    const stack = [{ patternNodeId, currentValue }];
 
-    switch (patternNode.kind) {
-      case NODE_KIND.ANY:
-        return;
+    while (stack.length > 0) {
+      const frame = stack.pop();
+      if (frame.extra) {
+        pushExtra(frame.patternNodeId, frame.label, frame.currentValue);
+        continue;
+      }
 
-      case NODE_KIND.CLOSED_PRODUCT:
-      case NODE_KIND.OPEN_PRODUCT: {
-        if (!(currentValue instanceof Product)) {
-          throw new Error(`Expected Product for pattern node ${patternNodeId}`);
-        }
-        const actualLabels = Object.keys(currentValue.product).sort();
-        const explicit = patternNode.edges.map((edge) => edge.label);
-        if (patternNode.kind === NODE_KIND.CLOSED_PRODUCT) {
-          if (actualLabels.length !== explicit.length || actualLabels.some((label, idx) => label !== explicit[idx])) {
-            throw new Error(`Closed product pattern does not match value fields [${actualLabels.join(", ")}]`);
+      const patternNode = base.nodes[frame.patternNodeId];
+      if (!patternNode) {
+        throw new Error(`Unknown pattern node ${frame.patternNodeId}`);
+      }
+      pushOccurrence(frame.patternNodeId, frame.currentValue);
+
+      switch (patternNode.kind) {
+        case NODE_KIND.ANY:
+          break;
+
+        case NODE_KIND.CLOSED_PRODUCT:
+        case NODE_KIND.OPEN_PRODUCT: {
+          if (!(frame.currentValue instanceof Product)) {
+            throw new Error(`Expected Product for pattern node ${frame.patternNodeId}`);
           }
-        } else {
-          for (const label of explicit) {
-            if (!(label in currentValue.product)) {
-              throw new Error(`Open product pattern is missing required field '${label}'`);
+          const actualLabels = Object.keys(frame.currentValue.product).sort();
+          const explicit = patternNode.edges.map((edge) => edge.label);
+          if (patternNode.kind === NODE_KIND.CLOSED_PRODUCT) {
+            if (actualLabels.length !== explicit.length || actualLabels.some((label, idx) => label !== explicit[idx])) {
+              throw new Error(`Closed product pattern does not match value fields [${actualLabels.join(", ")}]`);
+            }
+          } else {
+            for (const label of explicit) {
+              if (!(label in frame.currentValue.product)) {
+                throw new Error(`Open product pattern is missing required field '${label}'`);
+              }
             }
           }
-        }
 
-        const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
-        for (const label of actualLabels) {
-          if (explicitTargets.has(label)) {
-            collect(explicitTargets.get(label), currentValue.product[label]);
-          } else if (patternNode.kind === NODE_KIND.OPEN_PRODUCT) {
-            pushExtra(patternNodeId, label, currentValue.product[label]);
-          } else {
-            throw new Error(`Unexpected extra field '${label}' for closed product pattern`);
+          const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
+          for (let i = actualLabels.length - 1; i >= 0; i--) {
+            const label = actualLabels[i];
+            if (explicitTargets.has(label)) {
+              stack.push({
+                patternNodeId: explicitTargets.get(label),
+                currentValue: frame.currentValue.product[label]
+              });
+            } else if (patternNode.kind === NODE_KIND.OPEN_PRODUCT) {
+              stack.push({
+                extra: true,
+                patternNodeId: frame.patternNodeId,
+                label,
+                currentValue: frame.currentValue.product[label]
+              });
+            } else {
+              throw new Error(`Unexpected extra field '${label}' for closed product pattern`);
+            }
           }
+          break;
         }
-        return;
-      }
 
-      case NODE_KIND.CLOSED_UNION:
-      case NODE_KIND.OPEN_UNION: {
-        if (!(currentValue instanceof Variant)) {
-          throw new Error(`Expected Variant for pattern node ${patternNodeId}`);
-        }
-        const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
-        if (explicitTargets.has(currentValue.tag)) {
-          collect(explicitTargets.get(currentValue.tag), currentValue.value);
-          return;
-        }
-        if (patternNode.kind === NODE_KIND.OPEN_UNION) {
-          pushExtra(patternNodeId, currentValue.tag, currentValue.value);
-          return;
+        case NODE_KIND.CLOSED_UNION:
+        case NODE_KIND.OPEN_UNION: {
+          if (!(frame.currentValue instanceof Variant)) {
+            throw new Error(`Expected Variant for pattern node ${frame.patternNodeId}`);
+          }
+          const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
+          if (explicitTargets.has(frame.currentValue.tag)) {
+            stack.push({
+              patternNodeId: explicitTargets.get(frame.currentValue.tag),
+              currentValue: frame.currentValue.value
+            });
+            break;
+          }
+          if (patternNode.kind === NODE_KIND.OPEN_UNION) {
+            pushExtra(frame.patternNodeId, frame.currentValue.tag, frame.currentValue.value);
+            break;
+          }
+          throw new Error(`Unexpected variant tag '${frame.currentValue.tag}' for closed union pattern`);
         }
-        throw new Error(`Unexpected variant tag '${currentValue.tag}' for closed union pattern`);
-      }
 
-      default:
-        throw new Error(`Unknown pattern node kind: ${patternNode.kind}`);
+        default:
+          throw new Error(`Unknown pattern node kind: ${patternNode.kind}`);
+      }
     }
   }
 
@@ -714,47 +736,88 @@ function refinePatternForValue(pattern, value) {
 
 function coerceValueForPattern(pattern, value) {
   const base = normalizePattern(pattern);
-
-  function coerce(patternNodeId, currentValue) {
-    const patternNode = base.nodes[patternNodeId];
+  let result;
+  const stack = [{
+    patternNodeId: 0,
+    currentValue: value,
+    assign(coercedValue) {
+      result = coercedValue;
+    }
+  }];
+
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    if (frame.passthrough) {
+      frame.assign();
+      continue;
+    }
+    const patternNode = base.nodes[frame.patternNodeId];
     if (!patternNode) {
-      throw new Error(`Unknown pattern node ${patternNodeId}`);
+      throw new Error(`Unknown pattern node ${frame.patternNodeId}`);
     }
 
     switch (patternNode.kind) {
       case NODE_KIND.ANY:
-        return currentValue;
+        frame.assign(frame.currentValue);
+        break;
 
       case NODE_KIND.CLOSED_PRODUCT:
       case NODE_KIND.OPEN_PRODUCT: {
-        let productValue = currentValue;
-        if (currentValue instanceof Variant) {
-          productValue = new Product({ [currentValue.tag]: currentValue.value });
+        let productValue = frame.currentValue;
+        if (frame.currentValue instanceof Variant) {
+          productValue = new Product({ [frame.currentValue.tag]: frame.currentValue.value });
         }
         if (!(productValue instanceof Product)) {
-          throw new Error(`Expected Product for pattern node ${patternNodeId}`);
+          throw new Error(`Expected Product for pattern node ${frame.patternNodeId}`);
         }
 
         const explicitTargets = new Map(patternNode.edges.map((edge) => [edge.label, edge.target]));
         const product = {};
-        for (const [label, childValue] of Object.entries(productValue.product)) {
-          product[label] = explicitTargets.has(label)
-            ? coerce(explicitTargets.get(label), childValue)
-            : childValue;
+        frame.assign(new Product(product));
+        const entries = Object.entries(productValue.product);
+        for (let i = entries.length - 1; i >= 0; i--) {
+          const [label, childValue] = entries[i];
+          const target = explicitTargets.get(label);
+          if (target == null) {
+            stack.push({
+              assign() {
+                product[label] = childValue;
+              },
+              passthrough: true
+            });
+          } else {
+            stack.push({
+              patternNodeId: target,
+              currentValue: childValue,
+              assign(coercedValue) {
+                product[label] = coercedValue;
+              }
+            });
+          }
         }
-        return new Product(product);
+        break;
       }
 
       case NODE_KIND.CLOSED_UNION:
       case NODE_KIND.OPEN_UNION: {
-        if (!(currentValue instanceof Variant)) {
-          throw new Error(`Expected Variant for pattern node ${patternNodeId}`);
+        if (!(frame.currentValue instanceof Variant)) {
+          throw new Error(`Expected Variant for pattern node ${frame.patternNodeId}`);
+        }
+        const target = patternNode.edges.find((edge) => edge.label === frame.currentValue.tag)?.target;
+        const variant = new Variant(frame.currentValue.tag, undefined);
+        frame.assign(variant);
+        if (target == null) {
+          variant.value = frame.currentValue.value;
+        } else {
+          stack.push({
+            patternNodeId: target,
+            currentValue: frame.currentValue.value,
+            assign(coercedValue) {
+              variant.value = coercedValue;
+            }
+          });
         }
-        const target = patternNode.edges.find((edge) => edge.label === currentValue.tag)?.target;
-        return new Variant(
-          currentValue.tag,
-          target == null ? currentValue.value : coerce(target, currentValue.value)
-        );
+        break;
       }
 
       default:
@@ -762,7 +825,7 @@ function coerceValueForPattern(pattern, value) {
     }
   }
 
-  return coerce(0, value);
+  return result;
 }
 
 export { deriveClosedPattern, exportPatternGraph, refinePatternForValue, coerceValueForPattern, canonicalizePattern, intersectPropertyListPatterns, NODE_KIND };

package/codecs/runtime/prefix-codec.mjs

@@ -120,87 +120,121 @@ function choiceWidth(cardinality) {
 }
 
 function encodeNode(writer, value, pattern, patternNodeId) {
-  const patternNode = pattern.nodes[patternNodeId];
-  if (!patternNode) {
-    throw new Error(`Unknown pattern node ${patternNodeId}`);
-  }
-
-  switch (patternNode.kind) {
-    case NODE_KIND.ANY:
-      throw new Error("Pattern node 'any' is not directly encodable");
+  const stack = [{ value, patternNodeId }];
 
-    case NODE_KIND.OPEN_PRODUCT:
-    case NODE_KIND.CLOSED_PRODUCT: {
-      if (!(value instanceof Product)) {
-        throw new Error(`Expected Product for pattern node ${patternNodeId}`);
-      }
-      const actual = Object.keys(value.product).sort((a, b) => Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8")));
-      const expected = patternNode.edges.map((edge) => edge.label);
-      if (actual.length !== expected.length || actual.some((label, i) => label !== expected[i])) {
-        throw new Error(`Product fields do not match pattern node ${patternNodeId}`);
-      }
-      for (const edge of patternNode.edges) {
-        encodeNode(writer, value.product[edge.label], pattern, edge.target);
-      }
-      return;
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    const patternNode = pattern.nodes[frame.patternNodeId];
+    if (!patternNode) {
+      throw new Error(`Unknown pattern node ${frame.patternNodeId}`);
     }
 
-    case NODE_KIND.OPEN_UNION:
-    case NODE_KIND.CLOSED_UNION: {
-      if (!(value instanceof Variant)) {
-        throw new Error(`Expected Variant for pattern node ${patternNodeId}`);
+    switch (patternNode.kind) {
+      case NODE_KIND.ANY:
+        throw new Error("Pattern node 'any' is not directly encodable");
+
+      case NODE_KIND.OPEN_PRODUCT:
+      case NODE_KIND.CLOSED_PRODUCT: {
+        if (!(frame.value instanceof Product)) {
+          throw new Error(`Expected Product for pattern node ${frame.patternNodeId}`);
+        }
+        const actual = Object.keys(frame.value.product).sort((a, b) => Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8")));
+        const expected = patternNode.edges.map((edge) => edge.label);
+        if (actual.length !== expected.length || actual.some((label, i) => label !== expected[i])) {
+          throw new Error(`Product fields do not match pattern node ${frame.patternNodeId}`);
+        }
+        for (let i = patternNode.edges.length - 1; i >= 0; i--) {
+          const edge = patternNode.edges[i];
+          stack.push({ value: frame.value.product[edge.label], patternNodeId: edge.target });
+        }
+        break;
       }
-      const tagOrdinal = patternNode.edges.findIndex((edge) => edge.label === value.tag);
-      if (tagOrdinal === -1) {
-        throw new Error(`Variant tag '${value.tag}' is not present in pattern node ${patternNodeId}`);
+
+      case NODE_KIND.OPEN_UNION:
+      case NODE_KIND.CLOSED_UNION: {
+        if (!(frame.value instanceof Variant)) {
+          throw new Error(`Expected Variant for pattern node ${frame.patternNodeId}`);
+        }
+        const tagOrdinal = patternNode.edges.findIndex((edge) => edge.label === frame.value.tag);
+        if (tagOrdinal === -1) {
+          throw new Error(`Variant tag '${frame.value.tag}' is not present in pattern node ${frame.patternNodeId}`);
+        }
+        const width = choiceWidth(patternNode.edges.length);
+        writer.writeBits(tagOrdinal, width);
+        stack.push({ value: frame.value.value, patternNodeId: patternNode.edges[tagOrdinal].target });
+        break;
       }
-      const width = choiceWidth(patternNode.edges.length);
-      writer.writeBits(tagOrdinal, width);
-      encodeNode(writer, value.value, pattern, patternNode.edges[tagOrdinal].target);
-      return;
-    }
 
-    default:
-      throw new Error(`Unsupported pattern node kind ${patternNode.kind}`);
+      default:
+        throw new Error(`Unsupported pattern node kind ${patternNode.kind}`);
+    }
   }
 }
 
 function decodeNode(reader, pattern, patternNodeId) {
-  const patternNode = pattern.nodes[patternNodeId];
-  if (!patternNode) {
-    throw new Error(`Unknown pattern node ${patternNodeId}`);
-  }
-
-  switch (patternNode.kind) {
-    case NODE_KIND.ANY:
-      throw new Error("Pattern node 'any' is not directly decodable");
+  let result;
+  const stack = [{
+    patternNodeId,
+    assign(value) {
+      result = value;
+    }
+  }];
 
-    case NODE_KIND.OPEN_PRODUCT:
-    case NODE_KIND.CLOSED_PRODUCT: {
-      const product = {};
-      for (const edge of patternNode.edges) {
-        product[edge.label] = decodeNode(reader, pattern, edge.target);
-      }
-      return new Product(product);
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    const patternNode = pattern.nodes[frame.patternNodeId];
+    if (!patternNode) {
+      throw new Error(`Unknown pattern node ${frame.patternNodeId}`);
     }
 
-    case NODE_KIND.OPEN_UNION:
-    case NODE_KIND.CLOSED_UNION: {
-      if (patternNode.edges.length === 0) {
-        throw new Error(`Union pattern node ${patternNodeId} has no tags`);
+    switch (patternNode.kind) {
+      case NODE_KIND.ANY:
+        throw new Error("Pattern node 'any' is not directly decodable");
+
+      case NODE_KIND.OPEN_PRODUCT:
+      case NODE_KIND.CLOSED_PRODUCT: {
+        const product = {};
+        frame.assign(new Product(product));
+        for (let i = patternNode.edges.length - 1; i >= 0; i--) {
+          const edge = patternNode.edges[i];
+          stack.push({
+            patternNodeId: edge.target,
+            assign(value) {
+              product[edge.label] = value;
+            }
+          });
+        }
+        break;
       }
-      const width = choiceWidth(patternNode.edges.length);
-      const tagOrdinal = reader.readBits(width);
-      if (tagOrdinal >= patternNode.edges.length) {
-        throw new Error(`Choice ${tagOrdinal} is out of range for pattern node ${patternNodeId}`);
+
+      case NODE_KIND.OPEN_UNION:
+      case NODE_KIND.CLOSED_UNION: {
+        if (patternNode.edges.length === 0) {
+          throw new Error(`Union pattern node ${frame.patternNodeId} has no tags`);
+        }
+        const width = choiceWidth(patternNode.edges.length);
+        const tagOrdinal = reader.readBits(width);
+        if (tagOrdinal >= patternNode.edges.length) {
+          throw new Error(`Choice ${tagOrdinal} is out of range for pattern node ${frame.patternNodeId}`);
+        }
+        const edge = patternNode.edges[tagOrdinal];
+        const variant = new Variant(edge.label, undefined);
+        frame.assign(variant);
+        stack.push({
+          patternNodeId: edge.target,
+          assign(value) {
+            variant.value = value;
+          }
+        });
+        break;
       }
-      const edge = patternNode.edges[tagOrdinal];
-      return new Variant(edge.label, decodeNode(reader, pattern, edge.target));
-    }
 
-    default:
-      throw new Error(`Unsupported pattern node kind ${patternNode.kind}`);
+      default:
+        throw new Error(`Unsupported pattern node kind ${patternNode.kind}`);
+    }
   }
+
+  return result;
 }
 
 function preparePatternAndValue(value, propertyList) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.2.1",
+    "version": "6.2.2",
     "description": "k — a language for composing first-order partial functions over algebraic data types (products and tagged unions); includes runtime, type derivation, REPL, and codec toolchain",
     "main": "index.mjs",
     "scripts": {

package/scripts/run-tests.mjs

@@ -18,6 +18,7 @@ const tests = [
   ["tests/test-fingerprint.mjs", node, ["tests/test-fingerprint.mjs"]],
   ["tests/test-hash-fuzz.mjs", node, ["tests/test-hash-fuzz.mjs"]],
   ["tests/test-hash-normalization.mjs", node, ["tests/test-hash-normalization.mjs"]],
+  ["tests/test-deep-wire-value.mjs", node, ["tests/test-deep-wire-value.mjs"]],
   ["tests/test-k-object.mjs", node, ["tests/test-k-object.mjs"]],
   ["tests/test-repl.mjs", node, ["tests/test-repl.mjs"]],
   ["tests/test-kvm.mjs", node, ["tests/test-kvm.mjs"]],

package/tests/test-deep-wire-value.mjs

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import { Product, Variant } from "../Value.mjs";
+import { decodeWire, encodeToWire } from "../codecs/runtime/prefix-codec.mjs";
+
+const depth = 12000;
+const pattern = [
+  ["closed-union", [["+", 1]]],
+  ["closed-union", [["_", 2], ["1", 1]]],
+  ["closed-product", []]
+];
+
+let bits = new Variant("_", new Product({}));
+for (let i = 0; i < depth; i++) {
+  bits = new Variant("1", bits);
+}
+
+const wire = encodeToWire(new Variant("+", bits), pattern);
+const decoded = decodeWire(wire).value;
+assert.equal(decoded.tag, "+");
+
+bits = decoded.value;
+for (let i = 0; i < depth; i++) {
+  assert.equal(bits.tag, "1");
+  bits = bits.value;
+}
+assert.equal(bits.tag, "_");
+assert.deepEqual(bits.value.product, {});
+
+console.log("deep wire value: ok");