@fraczak/k 6.2.0 → 6.2.2

package/Examples/list.k

@@ -0,0 +1,7 @@
+list? = ?< {} nil, {X car, Y cdr} cons > = Y;
+nil = {} |nil list?;
+singleton = {() car, nil cdr} | cons list?;
+cons = {.car car, .cdr cdr} | cons list?;
+nil? = list? /nil nil;
+car = list? /cons .car;
+cdr = list? /cons .cdr;

package/Examples/nat.k

@@ -0,0 +1,12 @@
+$ nat = < {} 0, nat +1 >;
+0 = {} | 0 ;
+0? = $ nat { / 0 if, () then} .then;
+succ = | +1 $ nat ;
+pred = $nat / +1 ;
+add = ?{ $nat x, ... } = X <{.x pred x, .y succ y} ?X add, .y> ;
+mult = <
+    {{.x pred x, .y y} mult x, .y y} add,
+    0
+> ;
+
+succ {()x,()y} add

package/Examples/vhdl_to_k.k

@@ -0,0 +1,50 @@
+-- VHDL to K Translation Patterns
+
+-- VHDL: signal a : std_logic;
+-- K:    $ bit = <{} 0, {} 1>;
+
+-- VHDL: signal bus : std_logic_vector(7 downto 0);
+-- K:    $ byte = {bit 0, bit 1, bit 2, bit 3, bit 4, bit 5, bit 6, bit 7};
+
+-- VHDL: entity adder is port(a,b: in std_logic; sum: out std_logic); end;
+-- K:    adder = ${bit a, bit b} {.a a_out, .b b_out, xor_gate sum_out};
+
+-- VHDL: process(clk) begin if rising_edge(clk) then q <= d; end if; end;
+-- K:    dff = $bit .;  -- Identity (register holds value)
+
+-- VHDL: y <= a and b;
+-- K:    and_gate = ${bit a, bit b} <{.a.1 1, .b.1 1, 1}, 0>;
+
+-- VHDL: y <= a or b;  
+-- K:    or_gate = ${bit a, bit b} <{.a.0 0, .b.0 0, 0}, 1>;
+
+-- VHDL: y <= not a;
+-- K:    not_gate = $bit <{.0 0, 1}, {.1 1, 0}>;
+
+-- VHDL: with sel select y <= a when "00", b when "01", c when others;
+-- K:    mux = ${bit sel0, bit sel1, bit a, bit b, bit c} <
+--             {.sel0.0 0, .sel1.0 0, .a},
+--             {.sel0.1 1, .sel1.0 0, .b}, 
+--             .c>;
+
+-- VHDL: architecture of 4-bit adder
+four_bit_adder = ${
+  {bit 0, bit 1, bit 2, bit 3} a,
+  {bit 0, bit 1, bit 2, bit 3} b
+} {
+  {.a.0 a0, .b.0 b0} full_adder fa0,
+  {.a.1 a1, .b.1 b1, .fa0.carry c_in} full_adder fa1,
+  {.a.2 a2, .b.2 b2, .fa1.carry c_in} full_adder fa2,
+  {.a.3 a3, .b.3 b3, .fa2.carry c_in} full_adder fa3,
+  {.fa0.sum 0, .fa1.sum 1, .fa2.sum 2, .fa3.sum 3} sum,
+  .fa3.carry overflow
+};
+
+-- VHDL: Full adder component
+full_adder = ${bit a, bit b, bit c_in} {
+  {.a a_val, .b b_val} xor_gate ab_xor,
+  {.ab_xor xor_val, .c_in c_val} xor_gate sum,
+  {.a a_val, .b b_val} and_gate ab_and,
+  {.ab_xor xor_val, .c_in c_val} and_gate xor_cin_and,
+  {.ab_and and1, .xor_cin_and and2} or_gate carry
+};

package/README.md

@@ -195,6 +195,14 @@ Installed binary names are `k-` plus the source basename without `.mjs`, except
 for `k.mjs` itself. Source names that already include `k-`, such as
 `codecs/k-parse.mjs`, keep that name.
 
+## WebAssembly Backend
+
+The experimental WebAssembly backend lives in the separate
+[`fraczak/k-wasm`](https://github.com/fraczak/k-wasm) repository. Keeping the
+backend separate avoids adding its WABT dependency to the core runtime. External
+backends integrate with the compiler and binary codecs through
+[`backend-api.mjs`](backend-api.mjs).
+
 ## Node.js API
 
 ```js

package/backend-api.mjs

@@ -0,0 +1,12 @@
+export { annotate } from "./index.mjs";
+export { lowerToKVM, executeKVM } from "./kvm.mjs";
+export { decodeWire, encodeToWire } from "./codecs/runtime/prefix-codec.mjs";
+export { exportPatternGraph, NODE_KIND } from "./codecs/runtime/codec.mjs";
+export { patternToPropertyList, propertyListToPattern } from "./codecs/runtime/pattern-json.mjs";
+export { Product, Variant, fromObject } from "./Value.mjs";
+export { decodeObject, loadLibrary } from "./object.mjs";
+export { createState, evaluateInput } from "./repl.mjs";
+export { parse as parseFloat64, print as printFloat64 } from "./codecs/ieee.mjs";
+export { valueForCode } from "./repl-codecs.mjs";
+export { default as codes } from "./codes.mjs";
+export { default as run, run_converged } from "./run.mjs";

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}`);
+      }
     }
   }
 
@@ -614,6 +636,7 @@ function refinePatternForValue(pattern, value) {
     }
 
     if (baseNode.kind === NODE_KIND.CLOSED_PRODUCT || baseNode.kind === NODE_KIND.OPEN_PRODUCT) {
+      result.kind = NODE_KIND.CLOSED_PRODUCT;
       const values = occurrences.get(patternNodeId) || [];
       const explicit = new Map(baseNode.edges.map((edge) => [edge.label, edge.target]));
       let labels = [...explicit.keys()].sort();
@@ -713,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:
@@ -761,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) {