@fraczak/k 6.8.0 → 6.10.1

package/codecs/runtime/codec-sdk.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { stdin, stdout, stderr, exit } from "node:process";
+import { Value, isProduct, isVariant, withPattern } from "../../Value.mjs";
+import { decodeWire, encodeToWire } from "./prefix-codec.mjs";
+import { isMainEntrypoint } from "./cli-entry.mjs";
+import { patternFromFilter } from "./pattern-k.mjs";
+
+function readAll(stream) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    stream.on("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", reject);
+  });
+}
+
+function printUsage(fileName, doc) {
+  stdout.write(`Usage: ${fileName} --parse | --print\n\n`);
+  if (doc) {
+    stdout.write(`${doc.trim()}\n\n`);
+  }
+  stdout.write("Options:\n");
+  stdout.write("  --parse      Read external text from stdin, write binary pattern+value stream to stdout.\n");
+  stdout.write("  --print      Read binary pattern+value stream from stdin, write external text to stdout.\n");
+  stdout.write("  -h, --help   Show this help.\n");
+}
+
+function runCodecCLI(metaUrl, codec) {
+  if (typeof process === "undefined" || !process.argv) return;
+  if (!isMainEntrypoint(metaUrl, process.argv[1])) return;
+
+  const filePath = fileURLToPath(metaUrl);
+  const fileName = path.basename(filePath);
+  const args = process.argv.slice(2);
+
+  if (args.includes("-h") || args.includes("--help")) {
+    printUsage(fileName, codec.doc);
+    exit(0);
+  }
+
+  if (args.length !== 1 || (args[0] !== "--parse" && args[0] !== "--print")) {
+    stderr.write(`Usage: ${fileName} --parse | --print\n`);
+    stderr.write("Try '--help' for more information.\n");
+    exit(1);
+  }
+
+  const mode = args[0];
+
+  (async () => {
+    if (mode === "--parse") {
+      let parsed;
+      if (typeof codec.parse === "function" && codec.parse.length === 0) {
+        parsed = codec.parse();
+      } else {
+        const buf = await readAll(stdin);
+        if (codec.readBuffer) {
+          parsed = codec.parse(buf);
+        } else {
+          parsed = codec.parse(buf.toString("utf8"));
+        }
+      }
+      const pattern = parsed?.pattern || codec.pattern || null;
+      const wire = encodeToWire(parsed, pattern);
+      stdout.write(wire);
+    } else {
+      const buf = await readAll(stdin);
+      const { value } = decodeWire(buf);
+      const output = codec.print(value);
+      if (Buffer.isBuffer(output) || codec.addNewline === false) {
+        stdout.write(output);
+      } else {
+        stdout.write(`${output}\n`);
+      }
+    }
+  })().catch((err) => {
+    stderr.write(`${fileName}: ${err.message || String(err)}\n`);
+    exit(1);
+  });
+}
+
+export {
+  Value,
+  isProduct,
+  isVariant,
+  withPattern,
+  encodeToWire,
+  decodeWire,
+  isMainEntrypoint,
+  runCodecCLI,
+  patternFromFilter
+};

package/codecs/runtime/pattern-k.mjs

@@ -0,0 +1,45 @@
+import { annotate } from "../../index.mjs";
+import { exportPatternGraph } from "./codec.mjs";
+import { patternToPropertyList } from "./pattern-json.mjs";
+
+const patternCache = new Map();
+
+export function rootPatternIdFromMainRel(mainRel) {
+  if (!mainRel || !mainRel.typePatternGraph) {
+    throw new Error("Could not resolve __main__ relation");
+  }
+
+  switch (mainRel.def.op) {
+    case "filter":
+    case "code":
+      return mainRel.typePatternGraph.find(mainRel.def.patterns[0]);
+    default:
+      throw new Error(`Main expression must be a filter or a type name, got '${mainRel.def.op}'`);
+  }
+}
+
+export function patternFromFilter(script, options = {}) {
+  if (!script || typeof script !== "string") {
+    throw new Error("patternFromFilter requires a k script string");
+  }
+  const cacheKey = script.trim();
+  if (options && Object.keys(options).length === 0 && patternCache.has(cacheKey)) {
+    return patternCache.get(cacheKey);
+  }
+
+  const annotated = annotate(script, options);
+  const mainRel = annotated.rels.__main__;
+  const root = rootPatternIdFromMainRel(mainRel);
+  const pattern = exportPatternGraph(mainRel.typePatternGraph, root);
+  const propertyList = patternToPropertyList(pattern);
+
+  if (options && Object.keys(options).length === 0) {
+    patternCache.set(cacheKey, propertyList);
+  }
+  return propertyList;
+}
+
+export default {
+  patternFromFilter,
+  rootPatternIdFromMainRel
+};

package/codecs/string-codec.mjs

@@ -1,80 +1,54 @@
-import { NODE_KIND } from "./runtime/codec.mjs";
-import { decodeWire, encodeToWire } from "./runtime/prefix-codec.mjs";
-import { patternToPropertyList } from "./runtime/pattern-json.mjs";
+import { patternFromFilter } from "./runtime/codec-sdk.mjs";
 import { textToStringValue, stringValueToText } from "./runtime/unicode-string.mjs";
 
-const STRING_PATTERN = {
-  dictionary: [
-    "0", "1", "10",
-    "ascii", "bmp_common", "bmp_private_use",
-    "car", "cdr", "cons",
-    "h08_0F", "h10_7F", "h80_CF", "hD0_D7", "hE0_EF", "hF0_F7", "hF8", "hF9", "hFA_FB", "hFC_FD", "hFE_FF",
-    "hi",
-    "lo",
-    "mid",
-    "nil",
-    "p02_03", "p04_07", "p08_0F", "p10",
-    "plane", "plane0",
-    "supplementary_plane1", "supplementary_planes2_16",
-    "2", "3", "4", "5", "6", "7", "8", "9"
-  ],
-  nodes: [
-    { kind: NODE_KIND.CLOSED_UNION, edges: [ { label: "nil", target: 1 }, { label: "cons", target: 2 } ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [ { label: "car", target: 3 }, { label: "cdr", target: 0 } ] },
-    { kind: NODE_KIND.CLOSED_UNION, edges: [
-      { label: "ascii", target: 4 },
-      { label: "plane0", target: 6 },
-      { label: "bmp_common", target: 7 },
-      { label: "bmp_private_use", target: 10 },
-      { label: "supplementary_plane1", target: 12 },
-      { label: "supplementary_planes2_16", target: 13 }
-    ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [
-      { label: "6", target: 5 }, { label: "5", target: 5 }, { label: "4", target: 5 },
-      { label: "3", target: 5 }, { label: "2", target: 5 }, { label: "1", target: 5 }, { label: "0", target: 5 }
-    ] },
-    { kind: NODE_KIND.CLOSED_UNION, edges: [ { label: "0", target: 1 }, { label: "1", target: 1 } ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [
-      { label: "10", target: 5 }, { label: "9", target: 5 }, { label: "8", target: 5 }, { label: "7", target: 5 },
-      { label: "6", target: 5 }, { label: "5", target: 5 }, { label: "4", target: 5 }, { label: "3", target: 5 },
-      { label: "2", target: 5 }, { label: "1", target: 5 }, { label: "0", target: 5 }
-    ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [ { label: "hi", target: 8 }, { label: "lo", target: 9 } ] },
-    { kind: NODE_KIND.CLOSED_UNION, edges: [
-      { label: "h08_0F", target: 15 }, { label: "h10_7F", target: 16 }, { label: "h80_CF", target: 16 },
-      { label: "hD0_D7", target: 15 }, { label: "hF9", target: 1 },
-      { label: "hFA_FB", target: 17 }, { label: "hFC_FD", target: 17 }, { label: "hFE_FF", target: 17 }
-    ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [
-      { label: "7", target: 5 }, { label: "6", target: 5 }, { label: "5", target: 5 }, { label: "4", target: 5 },
-      { label: "3", target: 5 }, { label: "2", target: 5 }, { label: "1", target: 5 }, { label: "0", target: 5 }
-    ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [ { label: "hi", target: 11 }, { label: "lo", target: 9 } ] },
-    { kind: NODE_KIND.CLOSED_UNION, edges: [ { label: "hE0_EF", target: 18 }, { label: "hF0_F7", target: 15 }, { label: "hF8", target: 1 } ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [ { label: "mid", target: 9 }, { label: "lo", target: 9 } ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [ { label: "plane", target: 14 }, { label: "mid", target: 9 }, { label: "lo", target: 9 } ] },
-    { kind: NODE_KIND.CLOSED_UNION, edges: [ { label: "p02_03", target: 17 }, { label: "p04_07", target: 19 }, { label: "p08_0F", target: 15 }, { label: "p10", target: 1 } ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [ { label: "2", target: 5 }, { label: "1", target: 5 }, { label: "0", target: 5 } ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [
-      { label: "6", target: 5 }, { label: "5", target: 5 }, { label: "4", target: 5 },
-      { label: "3", target: 5 }, { label: "2", target: 5 }, { label: "1", target: 5 }, { label: "0", target: 5 }
-    ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [ { label: "0", target: 5 } ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [ { label: "3", target: 5 }, { label: "2", target: 5 }, { label: "1", target: 5 }, { label: "0", target: 5 } ] },
-    { kind: NODE_KIND.CLOSED_PRODUCT, edges: [ { label: "1", target: 5 }, { label: "0", target: 5 } ] }
-  ]
-};
+const STRING_PATTERN_PROPERTY_LIST = patternFromFilter(`
+$bit = < {} 0, {} 1 >;
+$bits1 = { bit 0 };
+$bits2 = { bit 0, bit 1 };
+$bits3 = { bit 0, bit 1, bit 2 };
+$bits4 = { bit 0, bit 1, bit 2, bit 3 };
+$bits7 = { bit 0, bit 1, bit 2, bit 3, bit 4, bit 5, bit 6 };
+$bits8 = { bit 0, bit 1, bit 2, bit 3, bit 4, bit 5, bit 6, bit 7 };
+$bits11 = { bit 0, bit 1, bit 2, bit 3, bit 4, bit 5, bit 6, bit 7, bit 8, bit 9, bit 10 };
 
-const STRING_PATTERN_PROPERTY_LIST = patternToPropertyList(STRING_PATTERN);
+$bmp_common_hi = <
+  bits3 h08_0F,
+  bits7 h10_7F,
+  bits7 h80_CF,
+  bits3 hD0_D7,
+  {} hF9,
+  bits1 hFA_FB,
+  bits1 hFC_FD,
+  bits1 hFE_FF
+>;
+$bmp_common = { bmp_common_hi hi, bits8 lo };
 
-function encodeText(text) {
-  return encodeToWire(textToStringValue(text), STRING_PATTERN_PROPERTY_LIST);
-}
+$bmp_private_hi = <
+  bits4 hE0_EF,
+  bits3 hF0_F7,
+  {} hF8
+>;
+$bmp_private_use = { bmp_private_hi hi, bits8 lo };
 
-function decodeText(buffer) {
-  const { value } = decodeWire(buffer);
-  return stringValueToText(value);
-}
+$plane2_16 = <
+  bits1 p02_03,
+  bits2 p04_07,
+  bits3 p08_0F,
+  {} p10
+>;
+$supplementary_planes2_16 = { plane2_16 plane, bits8 mid, bits8 lo };
+$supplementary_plane1 = { bits8 mid, bits8 lo };
 
-export { STRING_PATTERN, STRING_PATTERN_PROPERTY_LIST, textToStringValue, stringValueToText, encodeText, decodeText };
+$unicode_scalar = <
+  bits7 ascii,
+  bits11 plane0,
+  bmp_common bmp_common,
+  bmp_private_use bmp_private_use,
+  supplementary_plane1 supplementary_plane1,
+  supplementary_planes2_16 supplementary_planes2_16
+>;
+
+?< {} nil, { $unicode_scalar car, str cdr } cons > = str
+`);
+
+export { STRING_PATTERN_PROPERTY_LIST, textToStringValue, stringValueToText };

package/codecs/unit.mjs

@@ -1,76 +1,28 @@
 #!/usr/bin/env node
 
-import { stdin, stdout, argv, exit } from "node:process";
-import { Value, isProduct } from "../Value.mjs";
-import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
-import { decodeWire, encodeToWire } from "./runtime/prefix-codec.mjs";
+import { Value, isProduct, withPattern, patternFromFilter, runCodecCLI } from "./runtime/codec-sdk.mjs";
 
-function usage(stream = console.error) {
-  stream(`Usage: ${argv[1]} --parse | --print`);
-  stream("  --parse      Ignore stdin and write the unit binary pattern+value stream.");
-  stream("  --print      Validate the unit binary pattern+value stream and write {}.");
-  stream("  -h, --help   Show this help.");
-}
-
-const UNIT_PATTERN = [
-  ["closed-product", []]
-];
-const name = "unit";
-const patterns = [UNIT_PATTERN];
+export const doc = `
+Unit codec for {}.
 
-function readAll(stream) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    stream.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
-    stream.on("end", () => resolve(Buffer.concat(chunks)));
-    stream.on("error", reject);
-  });
-}
+Translates the empty product {} to/from binary pattern+value stream.
+`;
 
-function unitEncoding() {
-  return encodeToWire(Value.product({}), UNIT_PATTERN);
-}
+const UNIT_PATTERN = patternFromFilter("?{}");
 
-function parse() {
-  return Value.product({});
+export function parse() {
+  return withPattern(Value.product({}), UNIT_PATTERN);
 }
 
-function print(value) {
+export function print(value) {
   if (!isProduct(value) || Object.keys(value.product).length !== 0) {
     throw new Error("Input is not a unit value");
   }
   return "{}";
 }
 
-async function main() {
-  const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    usage(console.log);
-    exit(0);
-  }
-
-  if (args.length !== 1 || (args[0] !== "--parse" && args[0] !== "--print")) {
-    usage();
-    exit(1);
-  }
-
-  const expected = unitEncoding();
-
-  if (args[0] === "--parse") {
-    stdout.write(expected);
-    return;
-  }
-
-  const input = await readAll(stdin);
-  const { value } = decodeWire(input);
-  stdout.write(print(value));
-}
-
-if (isMainEntrypoint(import.meta.url, argv[1])) {
-  main().catch((error) => {
-    console.error(error.message || String(error));
-    exit(1);
-  });
-}
+runCodecCLI(import.meta.url, { parse, print, doc });
 
-export { UNIT_PATTERN, name, patterns, parse, print };
+export {
+  UNIT_PATTERN
+};

package/codecs/utf16.mjs

@@ -1,44 +1,20 @@
 #!/usr/bin/env node
 
-import { stdin, stdout, argv, exit } from "node:process";
-import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
+import { withPattern, runCodecCLI } from "./runtime/codec-sdk.mjs";
 import {
   STRING_PATTERN_PROPERTY_LIST,
-  encodeText,
-  decodeText,
   textToStringValue,
   stringValueToText
 } from "./string-codec.mjs";
 
-const name = "utf16";
-const patterns = [STRING_PATTERN_PROPERTY_LIST];
+export const doc = `
+UTF-16 text codec (BOM-aware).
 
-function parse(text) {
-  return textToStringValue(text);
-}
-
-function print(value) {
-  return stringValueToText(value);
-}
-
-function usage(stream = console.error) {
-  stream(`Usage: ${argv[1]} --parse | --print`);
-  stream("  --parse      Read UTF-16 text from stdin (BOM-aware), write binary pattern+value stream of k string.");
-  stream("  --print      Read binary pattern+value stream of k string, write UTF-16LE text with BOM.");
-  stream("  -h, --help   Show this help.");
-}
-
-function readAll(stream) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    stream.on("data", c => chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c)));
-    stream.on("end", () => resolve(Buffer.concat(chunks)));
-    stream.on("error", reject);
-  });
-}
+Reads UTF-16 text (LE/BE with BOM or LE without BOM), outputs UTF-16LE with BOM.
+`;
 
 function decodeUtf16Input(buf) {
-  if (buf.length === 0) return "";
+  if (!buf || buf.length === 0) return "";
 
   if (buf.length >= 2 && buf[0] === 0xfe && buf[1] === 0xff) {
     const src = buf.subarray(2);
@@ -66,33 +42,14 @@ function encodeUtf16Output(text) {
   return Buffer.concat([bomLe, Buffer.from(text, "utf16le")]);
 }
 
-async function main() {
-  const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    usage(console.log);
-    exit(0);
-  }
-
-  if (args.length !== 1 || (args[0] !== "--parse" && args[0] !== "--print")) {
-    usage();
-    exit(1);
-  }
-
-  const buf = await readAll(stdin);
-
-  if (args[0] === "--parse") {
-    const text = decodeUtf16Input(buf);
-    stdout.write(encodeText(text));
-  } else {
-    stdout.write(encodeUtf16Output(decodeText(buf)));
-  }
+export function parse(input) {
+  const text = Buffer.isBuffer(input) ? decodeUtf16Input(input) : String(input);
+  return withPattern(textToStringValue(text), STRING_PATTERN_PROPERTY_LIST);
 }
 
-if (isMainEntrypoint(import.meta.url, argv[1])) {
-  main().catch(err => {
-    console.error(err.message || String(err));
-    exit(1);
-  });
+export function print(value) {
+  const text = stringValueToText(value);
+  return encodeUtf16Output(text);
 }
 
-export { name, patterns, parse, print };
+runCodecCLI(import.meta.url, { parse, print, doc, readBuffer: true, addNewline: false });

package/codecs/utf8.mjs

@@ -1,69 +1,25 @@
 #!/usr/bin/env node
 
-import { stdin, stdout, argv, exit } from "node:process";
-import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
+import { withPattern, runCodecCLI } from "./runtime/codec-sdk.mjs";
 import {
   STRING_PATTERN_PROPERTY_LIST,
-  encodeText,
-  decodeText,
   textToStringValue,
   stringValueToText
 } from "./string-codec.mjs";
 
-const name = "utf8";
-const patterns = [STRING_PATTERN_PROPERTY_LIST];
+export const doc = `
+UTF-8 text codec.
 
-function parse(text) {
-  return textToStringValue(text);
-}
-
-function print(value) {
-  return stringValueToText(value);
-}
-
-function usage(stream = console.error) {
-  stream(`Usage: ${argv[1]} --parse | --print`);
-  stream("  --parse      Read UTF-8 text from stdin, write binary pattern+value stream of k string.");
-  stream("  --print      Read binary pattern+value stream of k string, write UTF-8 text.");
-  stream("  -h, --help   Show this help.");
-}
+Encodes/decodes text strings to/from the canonical k string pattern.
+`;
 
-function readAll(stream) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    stream.on("data", c => chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c)));
-    stream.on("end", () => resolve(Buffer.concat(chunks)));
-    stream.on("error", reject);
-  });
+export function parse(text) {
+  const value = textToStringValue(text);
+  return withPattern(value, STRING_PATTERN_PROPERTY_LIST);
 }
 
-async function main() {
-  const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    usage(console.log);
-    exit(0);
-  }
-
-  if (args.length !== 1 || (args[0] !== "--parse" && args[0] !== "--print")) {
-    usage();
-    exit(1);
-  }
-
-  const buf = await readAll(stdin);
-
-  if (args[0] === "--parse") {
-    const text = buf.toString("utf8");
-    stdout.write(encodeText(text));
-  } else {
-    stdout.write(decodeText(buf));
-  }
-}
-
-if (isMainEntrypoint(import.meta.url, argv[1])) {
-  main().catch(err => {
-    console.error(err.message || String(err));
-    exit(1);
-  });
+export function print(value) {
+  return stringValueToText(value);
 }
 
-export { name, patterns, parse, print };
+runCodecCLI(import.meta.url, { parse, print, doc, addNewline: false });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.8.0",
+    "version": "6.10.1",
     "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",
     "exports": {

package/patterns/from-k.mjs

@@ -2,9 +2,7 @@
 
 import fs from "node:fs";
 import { argv, exit, stdin, stdout } from "node:process";
-import k from "../index.mjs";
-import { exportPatternGraph } from "../codecs/runtime/codec.mjs";
-import { patternToPropertyList } from "../codecs/runtime/pattern-json.mjs";
+import { patternFromFilter } from "../codecs/runtime/pattern-k.mjs";
 
 function usage(prog) {
   console.error(`Usage: ${prog} [script-or-file]`);
@@ -33,20 +31,6 @@ function readAll(stream) {
   });
 }
 
-function rootPatternIdFromMainRel(mainRel) {
-  if (!mainRel || !mainRel.typePatternGraph) {
-    throw new Error("Could not resolve __main__ relation");
-  }
-
-  switch (mainRel.def.op) {
-    case "filter":
-    case "code":
-      return mainRel.typePatternGraph.find(mainRel.def.patterns[0]);
-    default:
-      throw new Error("Main expression must be a filter or a type name");
-  }
-}
-
 async function main() {
   const prog = argv[1];
   const args = argv.slice(2);
@@ -60,11 +44,7 @@ async function main() {
   }
 
   const script = args.length === 1 ? maybeReadFile(args[0]) : await readAll(stdin);
-  const annotated = k.annotate(script);
-  const mainRel = annotated.rels.__main__;
-  const rootPatternId = rootPatternIdFromMainRel(mainRel);
-  const pattern = exportPatternGraph(mainRel.typePatternGraph, rootPatternId);
-  const propertyList = patternToPropertyList(pattern);
+  const propertyList = patternFromFilter(script);
 
   stdout.write(`${JSON.stringify(propertyList)}\n`);
 }