@fraczak/k 7.1.0 → 8.0.0

package/codecs/runtime/show-value.mjs

@@ -6,7 +6,11 @@ function pLabel(label) {
   return nameRE.test(label) ? ` ${label}` : ` ${JSON.stringify(label)}`;
 }
 
-function propertyListToFilter(propertyList, varPrefix = "X") {
+function propertyListToFilter(
+  propertyList,
+  varPrefix = "X",
+  limit = Infinity
+) {
   if (!propertyList || propertyList.length === 0) return "(...)";
 
   const refCount = new Array(propertyList.length).fill(0);
@@ -22,9 +26,15 @@ function propertyListToFilter(propertyList, varPrefix = "X") {
   }
 
   const defined = new Set();
+  let curLen = 0;
 
   function fmt(nodeId) {
-    if (varNames.has(nodeId) && defined.has(nodeId)) return varNames.get(nodeId);
+    if (curLen >= limit) return "...";
+    if (varNames.has(nodeId) && defined.has(nodeId)) {
+      const name = varNames.get(nodeId);
+      curLen += name.length;
+      return name;
+    }
 
     const [kind, edges] = propertyList[nodeId];
     const hasVar = varNames.has(nodeId);
@@ -32,16 +42,35 @@ function propertyListToFilter(propertyList, varPrefix = "X") {
 
     const suffix = hasVar ? `=${varNames.get(nodeId)}` : "";
 
-    if (kind === "any") return hasVar ? varNames.get(nodeId) : "(...)";
+    if (kind === "any") {
+      const s = (hasVar ? varNames.get(nodeId) : "(...)") + suffix;
+      curLen += s.length;
+      return s;
+    }
 
     const isOpen = kind.startsWith("open-");
     const isProduct = kind.endsWith("product");
     const open = isProduct ? "{" : "<";
     const close = isProduct ? "}" : ">";
 
-    if (edges.length === 0 && !isOpen) return `${open}${close}${suffix}`;
+    if (edges.length === 0 && !isOpen) {
+      const s = `${open}${close}${suffix}`;
+      curLen += s.length;
+      return s;
+    }
 
-    const fields = edges.map(([label, target]) => `${fmt(target)}${pLabel(label)}`);
+    const fields = [];
+    for (let i = 0; i < edges.length; i++) {
+      if (curLen >= limit) {
+        fields.push("...");
+        break;
+      }
+      const [label, target] = edges[i];
+      const targetStr = fmt(target);
+      const labelStr = pLabel(label);
+      fields.push(`${targetStr}${labelStr}`);
+      curLen += targetStr.length + labelStr.length + 2;
+    }
     if (isOpen) fields.push("...");
     return `${open}${fields.join(", ")}${close}${suffix}`;
   }
@@ -49,81 +78,94 @@ function propertyListToFilter(propertyList, varPrefix = "X") {
   return fmt(0);
 }
 
-function valueToK(root) {
-  let result = "";
-  const stack = [{
-    val: root,
-    assign(s) { result = s; }
-  }];
+function valueToK(root, limit = Infinity) {
+  const out = [];
+  let curLen = 0;
+  const stack = [root];
 
   while (stack.length > 0) {
-    const frame = stack.pop();
-    if (frame.finishProduct) {
-      frame.assign(`{${frame.parts.join(", ")}}`);
+    if (curLen >= limit) {
+      out.push("...");
+      break;
+    }
+    const item = stack.pop();
+    if (typeof item === "string") {
+      if (curLen + item.length > limit) {
+        out.push(item.slice(0, Math.max(0, limit - curLen)));
+        out.push("...");
+        break;
+      }
+      out.push(item);
+      curLen += item.length;
       continue;
     }
-    if (frame.finishVariant) {
-      const base = frame.base;
-      const tags = frame.tags;
-      frame.assign(tags.length === 0 ? base : `${base}|${tags.reverse().join("|")}`);
+
+    if (item == null) {
+      const s = String(item);
+      if (curLen + s.length > limit) {
+        out.push(s.slice(0, Math.max(0, limit - curLen)));
+        out.push("...");
+        break;
+      }
+      out.push(s);
+      curLen += s.length;
       continue;
     }
 
-    const v = frame.val;
-    if (isVariant(v)) {
+    if (isVariant(item)) {
       const tags = [];
-      let curr = v;
+      let curr = item;
       while (isVariant(curr)) {
         tags.push(pLabel(curr.tag).trimStart());
         curr = curr.value;
+        if (tags.length > limit) break;
       }
-      const finishFrame = {
-        finishVariant: true,
-        tags,
-        base: "",
-        assign: frame.assign
-      };
-      stack.push(finishFrame);
-      stack.push({
-        val: curr,
-        assign(s) { finishFrame.base = s; }
-      });
+      if (tags.length > 0) {
+        stack.push("|" + tags.reverse().join("|"));
+      }
+      stack.push(curr);
       continue;
     }
 
-    if (isProduct(v)) {
-      const keys = Object.keys(v.product);
+    if (isProduct(item)) {
+      const keys = Object.keys(item.product);
       if (keys.length === 0) {
-        frame.assign("{}");
+        out.push("{}");
+        curLen += 2;
         continue;
       }
-      const parts = new Array(keys.length);
-      const finishFrame = {
-        finishProduct: true,
-        parts,
-        assign: frame.assign
-      };
-      stack.push(finishFrame);
+      out.push("{");
+      curLen += 1;
+      stack.push("}");
       for (let i = keys.length - 1; i >= 0; i--) {
         const k = keys[i];
-        const label = pLabel(k);
-        stack.push({
-          val: v.product[k],
-          assign(s) { parts[i] = `${s}${label}`; }
-        });
+        if (i < keys.length - 1) {
+          stack.push(", ");
+        }
+        stack.push(pLabel(k));
+        stack.push(item.product[k]);
       }
       continue;
     }
 
-    frame.assign(String(v));
+    const s = String(item);
+    if (curLen + s.length > limit) {
+      out.push(s.slice(0, Math.max(0, limit - curLen)));
+      out.push("...");
+      break;
+    }
+    out.push(s);
+    curLen += s.length;
   }
 
-  return result;
+  return out.join("");
 }
 
-function valueWithEnvelopeToK(value) {
+function valueWithEnvelopeToK(value, limit = Infinity) {
   if (value === undefined) return "... undefined";
-  return `${valueToK(value)} ?${propertyListToFilter(value.pattern)}`;
+  const valStr = valueToK(value, limit);
+  const patStr = propertyListToFilter(value.pattern, "X", limit);
+  return `${valStr} ?${patStr}`;
 }
 
 export { propertyListToFilter, valueToK, valueWithEnvelopeToK };

package/codecs/runtime/unicode-string.mjs

@@ -3,6 +3,15 @@ import { Value, isProduct, isVariant } from "../../Value.mjs";
 const UNIT = Value.product({});
 const BIT0 = Value.variant("0", UNIT);
 const BIT1 = Value.variant("1", UNIT);
+const BIT_KEYS = [
+  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"
+];
+
+let lazyStringDecoder = null;
+
+function setLazyStringDecoder(fn) {
+  lazyStringDecoder = fn;
+}
 
 function bitValue(bit) {
   return bit === 0 ? BIT0 : BIT1;
@@ -25,7 +34,8 @@ function requireVariant(value, where) {
 function bitsProduct(width, n) {
   const product = {};
   for (let i = width - 1; i >= 0; i--) {
-    product[String(i)] = bitValue((n >> i) & 1);
+    const key = i < BIT_KEYS.length ? BIT_KEYS[i] : String(i);
+    product[key] = bitValue((n >> i) & 1);
   }
   return Value.product(product);
 }
@@ -34,7 +44,8 @@ function parseBitsProduct(value, maxBit, where) {
   const product = requireProduct(value, where);
   let n = 0;
   for (let i = maxBit; i >= 0; i--) {
-    const entry = requireVariant(product[String(i)], `${where}.bit${i}`);
+    const key = i < BIT_KEYS.length ? BIT_KEYS[i] : String(i);
+    const entry = requireVariant(product[key], `${where}.bit${i}`);
     if (entry.tag !== "0" && entry.tag !== "1") {
       throw new Error(`${where}.bit${i}: expected tag 0 or 1`);
     }
@@ -194,20 +205,31 @@ function textToStringValue(text) {
 }
 
 function stringValueToText(value) {
-  let out = "";
+  if (lazyStringDecoder) {
+    const fast = lazyStringDecoder(value);
+    if (fast !== null) return fast;
+  }
+
+  const chunks = [];
+  let chunk = "";
   let cursor = value;
 
   while (true) {
     const list = requireVariant(cursor, "string");
     if (list.tag === "nil") {
       requireProduct(list.value, "string.nil");
-      return out;
+      if (chunk.length > 0) chunks.push(chunk);
+      return chunks.join("");
     }
     if (list.tag !== "cons") {
       throw new Error(`Unsupported string list tag: ${list.tag}`);
     }
     const pair = requireProduct(list.value, "string.cons");
-    out += String.fromCodePoint(unicodeValueToCodePoint(pair.car));
+    chunk += String.fromCodePoint(unicodeValueToCodePoint(pair.car));
+    if (chunk.length >= 8192) {
+      chunks.push(chunk);
+      chunk = "";
+    }
     cursor = pair.cdr;
   }
 }
@@ -216,5 +238,6 @@ export {
   codePointToUnicodeValue,
   unicodeValueToCodePoint,
   textToStringValue,
-  stringValueToText
+  stringValueToText,
+  setLazyStringDecoder
 };

package/codecs/show.mjs

@@ -51,6 +51,10 @@ async function main() {
     else { usage(); process.exit(1); }
   }
 
+  stdout.on("error", (err) => {
+    if (err.code === "EPIPE") process.exit(0);
+  });
+
   const buffer = fileArg ? fs.readFileSync(fileArg) : await readAll(stdin);
 
   // forward unchanged to stdout

package/codecs/utf16.mjs

@@ -10,7 +10,8 @@ import {
 export const doc = `
 UTF-16 text codec (BOM-aware).
 
-Reads UTF-16 text (LE/BE with BOM or LE without BOM), outputs UTF-16LE with BOM.
+Reads UTF-16 text (LE/BE with BOM or LE without BOM),
+outputs UTF-16LE with BOM.
 `;
 
 function decodeUtf16Input(buf) {

package/core.k

@@ -9,9 +9,11 @@
 -- §1. Bits
 ---------------------------------------------------------------
 
-bit? = ?< {} 0, {} 1 >;
+bit[] = < {} 0, {} 1 >;
+bits[] = < {} _, B 0, B 1 > = B;
 
-bits? = ?< {} _, bits? 0, bits? 1 > = bits?;
+bit? = ? bit[];
+bits? = ? bits[];
 
 _ = {}|_;
 
@@ -22,52 +24,66 @@ _ = {}|_;
 -- §2. Unicode and String
 ---------------------------------------------------------------
 
-string? = ? <
-  {} nil,
-  {
-    <
-      {
-        < {} 0, {} 1 >=Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6
-      }=Bits7 ascii,
-      {
-        <
-          { Bit 0, Bit 1, Bit 2 }=Bits3 h08_0F,
-          Bits7 h10_7F,
-          Bits7 h80_CF,
-          Bits3 hD0_D7,
-          {} hF9,
-          { Bit 0 }=Bits1 hFA_FB,
-          Bits1 hFC_FD,
-          Bits1 hFE_FF
-        > hi,
-        { Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6, Bit 7 }=Bits8 lo
-      } bmp_common,
-      {
-        <
-          { Bit 0, Bit 1, Bit 2, Bit 3 } hE0_EF,
-          Bits3 hF0_F7,
-          {} hF8
-        > hi,
-        Bits8 lo
-      } bmp_private_use,
-      {
-        Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6, Bit 7, Bit 8, Bit 9, Bit 10
-      } plane0,
-      { Bits8 mid, Bits8 lo } supplementary_plane1,
-      {
-        <
-          Bits1 p02_03,
-          { Bit 0, Bit 1 } p04_07,
-          Bits3 p08_0F,
-          {} p10
-        > plane,
-        Bits8 mid,
-        Bits8 lo
-      } supplementary_planes2_16
-    > car,
-    String cdr
-  } cons
-> = String;
+-- 8-bit octet used as a building block for UTF-8 payload pieces.
+byte[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3,
+  bit[] 4, bit[] 5, bit[] 6, bit[] 7
+};
+
+-- 7-bit ASCII code point payload (U+0000..U+007F).
+ascii[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3,
+  bit[] 4, bit[] 5, bit[] 6
+};
+
+-- High-byte classes for common BMP ranges, excluding surrogate
+-- and private-use partitions.
+bmp_hi_common[] = <
+  { bit[] 0, bit[] 1, bit[] 2 } h08_0F,
+  ascii[] h10_7F,
+  ascii[] h80_CF,
+  { bit[] 0, bit[] 1, bit[] 2 } hD0_D7,
+  {} hF9,
+  { bit[] 0 } hFA_FB,
+  { bit[] 0 } hFC_FD,
+  { bit[] 0 } hFE_FF
+>;
+
+-- High-byte classes for BMP private-use/high-reserved slices.
+bmp_hi_private_use[] = <
+  { bit[] 0, bit[] 1, bit[] 2, bit[] 3 } hE0_EF,
+  { bit[] 0, bit[] 1, bit[] 2 } hF0_F7,
+  {} hF8
+>;
+
+-- 11-bit payload used for Plane 0 code points U+0080..U+07FF.
+plane0[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3, bit[] 4,
+  bit[] 5, bit[] 6, bit[] 7, bit[] 8, bit[] 9, bit[] 10
+};
+
+-- Plane selector for supplementary code points in Planes 2..16.
+plane_02_10[] = <
+  { bit[] 0 } p02_03,
+  { bit[] 0, bit[] 1 } p04_07,
+  { bit[] 0, bit[] 1, bit[] 2 } p08_0F,
+  {} p10
+>;
+
+-- Canonical Unicode scalar-value partition used by string encoding.
+unicode[] = <
+  ascii[] ascii,
+  { bmp_hi_common[] hi, byte[] lo } bmp_common,
+  { bmp_hi_private_use[] hi, byte[] lo } bmp_private_use,
+  plane0[] plane0,
+  { byte[] mid, byte[] lo } supplementary_plane1,
+  { plane_02_10[] plane, byte[] mid, byte[] lo } supplementary_planes2_16
+>;
+
+-- Linked-list string: nil or (unicode car, string cdr).
+string[] = < {} nil, { unicode[] car, S cdr } cons > = S;
+
+string? = ? string[];
 
 ---------------------------------------------------------------
 -- §3. Pattern
@@ -82,72 +98,20 @@ string? = ? <
 -- to decode any value, first decode a pattern under that constant,
 -- then decode the value under the pattern just obtained.
 
-pattern? = ? <
-  {} nil,
-  {
-    <
-      {} any,
-      <
-        {} nil,
-        {
-          {
-            <
-              {} nil,
-              {
-                <
-                  {
-                    < {} 0, {} 1 >=Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6
-                  }=Bits7 ascii,
-                  {
-                    <
-                      { Bit 0, Bit 1, Bit 2 }=Bits3 h08_0F,
-                      Bits7 h10_7F,
-                      Bits7 h80_CF,
-                      Bits3 hD0_D7,
-                      {} hF9,
-                      { Bit 0 }=Bits1 hFA_FB,
-                      Bits1 hFC_FD,
-                      Bits1 hFE_FF
-                    > hi,
-                    { Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6, Bit 7 }=Bits8 lo
-                  } bmp_common,
-                  {
-                    <
-                      { Bit 0, Bit 1, Bit 2, Bit 3 } hE0_EF,
-                      Bits3 hF0_F7,
-                      {} hF8
-                    > hi,
-                    Bits8 lo
-                  } bmp_private_use,
-                  {
-                    Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6, Bit 7, Bit 8, Bit 9, Bit 10
-                  } plane0,
-                  { Bits8 mid, Bits8 lo } supplementary_plane1,
-                  {
-                    <
-                      Bits1 p02_03,
-                      { Bit 0, Bit 1 } p04_07,
-                      Bits3 p08_0F,
-                      {} p10
-                    > plane,
-                    Bits8 mid,
-                    Bits8 lo
-                  } supplementary_planes2_16
-                > car,
-                String cdr
-              } cons
-            > = String label,
-            < Bits 0, Bits 1, {} _ > = Bits target
-          } car,
-          Edges cdr
-        } cons
-      > = Edges open-product,
-      Edges open-union,
-      Edges closed-product,
-      Edges closed-union
-    > car,
-    Pattern cdr
-  } cons
-> = Pattern;
+edge[] = { string[] label, bits[] target };
+
+edges[] = < {} nil, { edge[] car, E cdr } cons > = E;
+
+node[] = <
+  {} any,
+  edges[] open-product,
+  edges[] open-union,
+  edges[] closed-product,
+  edges[] closed-union
+>;
+
+pattern[] = < {} nil, { node[] car, P cdr } cons > = P;
+
+pattern? = ? pattern[];
 
 pattern?

package/index.mjs

@@ -2,6 +2,7 @@ import { parse } from "./parser.mjs";
 import { fromObject, isValue } from "./Value.mjs";
 import { parseValue } from "./valueIO.mjs";
 import { compileTypes } from "./compiler.mjs";
+import { expandPatternsInRels } from "./named-patterns.mjs";
 import run from "./run.mjs";
 import codes from "./codes.mjs";
 
@@ -37,6 +38,8 @@ function annotate(script, options = {}) {
   const representatives = codes.register(defs.codes);
   const rels = {...defs.rels, "__main__": {def: exp}};
 
+  expandPatternsInRels(rels, defs.patterns || {}, options);
+
   // Inject library relations into the rels table so @hash refs resolve
   if (options.libraries) {
     for (const lib of options.libraries) {