@fraczak/k 5.1.2 → 6.0.1

package/codecs/json-codec.mjs

@@ -0,0 +1,215 @@
+import { Product, Variant } from "../Value.mjs";
+import { STRING_PATTERN_PROPERTY_LIST, textToStringValue, stringValueToText } from "./string-codec.mjs";
+import { FLOAT64_PATTERN } from "./runtime/ieee-pattern.mjs";
+
+const UNIT = new Product({});
+const BOOL_PATTERN = [
+  ["closed-union", [["false", 1], ["true", 1]]],
+  ["closed-product", []]
+];
+const NULL_PATTERN = [
+  ["closed-union", [["null", 1]]],
+  ["closed-product", []]
+];
+
+function bitValue(bit) {
+  return new Variant(bit === 0 ? "0" : "1", UNIT);
+}
+
+function bitsProduct(width, value) {
+  const big = BigInt(value);
+  const product = {};
+  for (let i = width - 1; i >= 0; i--) {
+    product[String(i)] = bitValue(Number((big >> BigInt(i)) & 1n));
+  }
+  return new Product(product);
+}
+
+function encodeNumberToValue(number) {
+  const buf = Buffer.alloc(8);
+  buf.writeDoubleBE(number, 0);
+  const bits = buf.readBigUInt64BE(0);
+  const sign = Number((bits >> 63n) & 1n);
+  const exponent = Number((bits >> 52n) & 0x7ffn);
+  const fraction = bits & ((1n << 52n) - 1n);
+
+  return new Product({
+    sign: new Variant(sign === 0 ? "+" : "-", UNIT),
+    exponent: bitsProduct(11, exponent),
+    fraction: bitsProduct(52, fraction)
+  });
+}
+
+function requireProduct(value, where) {
+  if (!(value instanceof Product)) {
+    throw new Error(`${where}: expected Product`);
+  }
+  return value.product;
+}
+
+function requireVariant(value, where) {
+  if (!(value instanceof Variant)) {
+    throw new Error(`${where}: expected Variant`);
+  }
+  return value;
+}
+
+function parseBitsProduct(value, maxBit, where) {
+  const product = requireProduct(value, where);
+  let n = 0n;
+  for (let i = maxBit; i >= 0; i--) {
+    const entry = requireVariant(product[String(i)], `${where}.bit${i}`);
+    if (entry.tag !== "0" && entry.tag !== "1") {
+      throw new Error(`${where}.bit${i}: expected tag 0 or 1`);
+    }
+    n = (n << 1n) | BigInt(entry.tag === "1" ? 1 : 0);
+  }
+  return n;
+}
+
+function decodeValueToNumber(value) {
+  const product = requireProduct(value, "json.number");
+  const sign = requireVariant(product.sign, "json.number.sign");
+  if (sign.tag !== "+" && sign.tag !== "-") {
+    throw new Error(`json.number.sign: expected + or -, got ${sign.tag}`);
+  }
+  const exponent = parseBitsProduct(product.exponent, 10, "json.number.exponent");
+  const fraction = parseBitsProduct(product.fraction, 51, "json.number.fraction");
+
+  const bits =
+    (BigInt(sign.tag === "-" ? 1 : 0) << 63n) |
+    (exponent << 52n) |
+    fraction;
+
+  const buf = Buffer.alloc(8);
+  buf.writeBigUInt64BE(bits, 0);
+  return buf.readDoubleBE(0);
+}
+
+function fromJsonValue(value) {
+  if (value === null) {
+    return new Variant("null", UNIT);
+  }
+  if (typeof value === "boolean") {
+    return new Variant(value ? "true" : "false", UNIT);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("JSON numbers must be finite");
+    }
+    return encodeNumberToValue(value);
+  }
+  if (typeof value === "string") {
+    return textToStringValue(value);
+  }
+  if (Array.isArray(value)) {
+    return new Product(
+      value.reduce((product, item, index) => {
+        product[String(index)] = fromJsonValue(item);
+        return product;
+      }, {})
+    );
+  }
+  if (value && typeof value === "object") {
+    return new Product(
+      Object.keys(value).reduce((product, key) => {
+        product[key] = fromJsonValue(value[key]);
+        return product;
+      }, {})
+    );
+  }
+  throw new Error(`Unsupported JSON value: ${value}`);
+}
+
+function composePattern(kind, entries) {
+  const result = [[kind, []]];
+
+  for (const [label, childPattern] of entries) {
+    const offset = result.length;
+    result[0][1].push([label, offset]);
+    for (const [childKind, childEdges] of childPattern) {
+      result.push([
+        childKind,
+        childEdges.map(([edgeLabel, target]) => [edgeLabel, target + offset])
+      ]);
+    }
+  }
+
+  return result;
+}
+
+function patternFromJsonValue(value) {
+  if (value === null) return NULL_PATTERN;
+  if (typeof value === "boolean") return BOOL_PATTERN;
+  if (typeof value === "number") return FLOAT64_PATTERN;
+  if (typeof value === "string") return STRING_PATTERN_PROPERTY_LIST;
+  if (Array.isArray(value)) {
+    return composePattern(
+      "closed-product",
+      value.map((item, index) => [String(index), patternFromJsonValue(item)])
+    );
+  }
+  if (value && typeof value === "object") {
+    return composePattern(
+      "closed-product",
+      Object.keys(value)
+        .sort((a, b) => Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8")))
+        .map((key) => [key, patternFromJsonValue(value[key])])
+    );
+  }
+  throw new Error(`Unsupported JSON value: ${value}`);
+}
+
+function toJsonValue(value) {
+  if (value instanceof Variant) {
+    if (value.tag === "null") {
+      requireProduct(value.value, "json.null");
+      return null;
+    }
+    if (value.tag === "true") {
+      requireProduct(value.value, "json.true");
+      return true;
+    }
+    if (value.tag === "false") {
+      requireProduct(value.value, "json.false");
+      return false;
+    }
+    return stringValueToText(value);
+  }
+
+  const product = requireProduct(value, "json.value");
+  const keys = Object.keys(product);
+  const isArray = keys.every((key, index) => key === String(index));
+
+  if (isArray) {
+    return keys.map((key) => {
+      const child = product[key];
+      if (child instanceof Variant) return toJsonValue(child);
+      if (child instanceof Product) {
+        try {
+          return decodeValueToNumber(child);
+        } catch {}
+      }
+      return toJsonValue(child);
+    });
+  }
+
+  // Distinguish object from number by shape first.
+  const numberKeys = ["exponent", "fraction", "sign"];
+  if (keys.length === numberKeys.length && numberKeys.every((key) => key in product)) {
+    return decodeValueToNumber(value);
+  }
+
+  // Distinguish object from string list by trying the string decoder.
+  try {
+    return stringValueToText(value);
+  } catch {}
+
+  return keys.reduce((result, key) => {
+    result[key] = toJsonValue(product[key]);
+    return result;
+  }, {});
+}
+
+export { fromJsonValue, toJsonValue, patternFromJsonValue, encodeNumberToValue, decodeValueToNumber, BOOL_PATTERN, NULL_PATTERN };
+export default { fromJsonValue, toJsonValue, patternFromJsonValue, encodeNumberToValue, decodeValueToNumber, BOOL_PATTERN, NULL_PATTERN };

package/codecs/json.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+import { stdin, stdout, argv, exit } from "node:process";
+import { decodeWire, encodeToWire } from "./runtime/prefix-codec.mjs";
+import { fromJsonValue, toJsonValue, patternFromJsonValue } from "./json-codec.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);
+  });
+}
+
+async function main() {
+  const args = argv.slice(2);
+  if (args.length !== 1 || (args[0] !== "--parse" && args[0] !== "--print")) {
+    console.error("Usage: json.mjs --parse | --print");
+    console.error("  --parse  read JSON from stdin, write binary pattern+value stream");
+    console.error("  --print  read binary pattern+value stream from stdin, write JSON");
+    exit(1);
+  }
+
+  const buf = await readAll(stdin);
+
+  if (args[0] === "--parse") {
+    const json = JSON.parse(buf.toString("utf8"));
+    const value = fromJsonValue(json);
+    stdout.write(encodeToWire(value, patternFromJsonValue(json)));
+  } else {
+    const { value } = decodeWire(buf);
+    stdout.write(`${JSON.stringify(toJsonValue(value))}\n`);
+  }
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message || String(error));
+  exit(1);
+});

package/codecs/k-parse.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import { argv, stdin, exit, stdout } from "node:process";
+import k from "../index.mjs";
+import { parseValue } from "../valueIO.mjs";
+import { exportPatternGraph } from "./runtime/codec.mjs";
+import { patternToPropertyList } from "./runtime/pattern-json.mjs";
+import { encodeToWire } from "./runtime/prefix-codec.mjs";
+
+function usage(prog) {
+  console.error(`Usage: ${prog} [--input-type <type-script|type-file> | --input-pattern <pattern-script|pattern-file>] [value-file]`);
+  console.error("  Parse a textual k value and emit the self-hosted binary pattern+value stream.");
+  console.error("  If no pattern or type is provided, derive a closed pattern from the value.");
+}
+
+function maybeReadFile(s) {
+  if (!s) return s;
+  if (fs.existsSync(s) && fs.statSync(s).isFile()) {
+    return fs.readFileSync(s, "utf8");
+  }
+  return s;
+}
+
+function readAll(stream) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk) => chunks.push(chunk));
+    stream.on("end", () => resolve(Buffer.concat(chunks.map((c) => Buffer.isBuffer(c) ? c : Buffer.from(c)))));
+    stream.on("error", reject);
+  });
+}
+
+function propertyListFromScript(script) {
+  const annotated = k.annotate(script);
+  const mainRel = annotated.rels.__main__;
+  if (!mainRel || !mainRel.typePatternGraph) {
+    throw new Error("Could not resolve __main__ relation");
+  }
+  if (mainRel.def.op !== "filter" && mainRel.def.op !== "code") {
+    throw new Error("Input script must end with a filter or a type name");
+  }
+  const rootPatternId = mainRel.typePatternGraph.find(mainRel.def.patterns[0]);
+  const pattern = exportPatternGraph(mainRel.typePatternGraph, rootPatternId);
+  return patternToPropertyList(pattern);
+}
+
+async function main() {
+  const prog = argv[1];
+  const args = argv.slice(2);
+
+  let inputTypeArg = null;
+  let inputPatternArg = null;
+  let valueFile = null;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--input-type") {
+      inputTypeArg = args[++i];
+    } else if (args[i] === "--input-pattern") {
+      inputPatternArg = args[++i];
+    } else if (valueFile == null) {
+      valueFile = args[i];
+    } else {
+      usage(prog);
+      return exit(1);
+    }
+  }
+
+  if (inputTypeArg != null && inputPatternArg != null) {
+    usage(prog);
+    return exit(1);
+  }
+
+  const inputBuffer = valueFile ? fs.readFileSync(valueFile) : await readAll(stdin);
+  const inputText = inputBuffer.toString("utf8");
+  const value = parseValue(inputText, null, null);
+
+  const propertyList = (() => {
+    if (inputTypeArg != null) return propertyListFromScript(maybeReadFile(inputTypeArg));
+    if (inputPatternArg != null) return propertyListFromScript(maybeReadFile(inputPatternArg));
+    return null;
+  })();
+
+  stdout.write(encodeToWire(value, propertyList));
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message || String(error));
+  process.exit(1);
+});

package/codecs/k-pattern.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import { argv, exit, stdin, stdout } from "node:process";
+import k from "../index.mjs";
+import { exportPatternGraph } from "./runtime/codec.mjs";
+import { patternToPropertyList } from "./runtime/pattern-json.mjs";
+
+function usage(prog) {
+  console.error(`Usage: ${prog} [script-or-file]`);
+  console.error("  Read a k script from a file argument or stdin.");
+  console.error("  The main expression must be a filter or a type name.");
+  console.error("  Output is the canonical JSON pattern array.");
+  console.error("  Example:");
+  console.error(`    cat pattern.k | ${prog}`);
+  console.error(`    ${prog} '$ bits = < {} _, bits 0, bits 1 >; ?< {} nil, { $bits car, X cdr } cons > = X'`);
+}
+
+function maybeReadFile(s) {
+  if (!s) return s;
+  if (fs.existsSync(s) && fs.statSync(s).isFile()) {
+    return fs.readFileSync(s, "utf8");
+  }
+  return s;
+}
+
+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).toString("utf8")));
+    stream.on("error", reject);
+  });
+}
+
+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);
+  if (args.includes("--help") || args.includes("-h")) {
+    usage(prog);
+    return exit(0);
+  }
+  if (args.length > 1) {
+    usage(prog);
+    return exit(1);
+  }
+
+  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);
+
+  stdout.write(`${JSON.stringify(propertyList)}\n`);
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message || String(error));
+  process.exit(1);
+});

package/codecs/k-print.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import { argv, stdin, stdout } from "node:process";
+import { decodeWire } from "./runtime/prefix-codec.mjs";
+
+function readAll(stream) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk) => chunks.push(chunk));
+    stream.on("end", () => resolve(Buffer.concat(chunks.map((c) => Buffer.isBuffer(c) ? c : Buffer.from(c)))));
+    stream.on("error", reject);
+  });
+}
+
+async function main() {
+  const args = argv.slice(2);
+  let debug = false;
+  let fileArg = null;
+
+  for (const arg of args) {
+    if (arg === "--debug") {
+      debug = true;
+    } else if (fileArg == null) {
+      fileArg = arg;
+    } else {
+      throw new Error("Usage: k-print [--debug] [file]");
+    }
+  }
+
+  const input = fileArg ? fs.createReadStream(fileArg) : stdin;
+  const buffer = await readAll(input);
+  const { pattern, value } = decodeWire(buffer);
+
+  if (debug) {
+    stdout.write(`${JSON.stringify({ pattern, value })}\n`);
+    return;
+  }
+
+  stdout.write(`${JSON.stringify(value)}\n`);
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message || String(error));
+  process.exit(1);
+});