@fraczak/k 6.1.1 → 6.1.3

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "@fraczak/k",
-    "version": "6.1.1",
+    "version": "6.1.3",
     "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": {
         "prepare": "jiwson -m es6 parser.jison -o parser.mjs; jiwson -m es6 valueParser.jison -o valueParser.mjs; ",
-        "test": "node test.mjs; for f in Code-derivation-tests/*.mjs; do echo $f; node $f; done; node test-fingerprint.mjs; node test-hash-fuzz.mjs; node test-hash-normalization.mjs; node test-k-object.mjs; node test-repl.mjs; ./tests.sh",
+        "test": "node test.mjs; for f in Code-derivation-tests/*.mjs; do echo $f; node $f; done; node test-fingerprint.mjs; node test-hash-fuzz.mjs; node test-hash-normalization.mjs; node test-k-object.mjs; node test-repl.mjs; node test-ieee-arithmetic.mjs; ./tests.sh",
+        "perf:idempotency": "node scripts/benchmark-idempotency.mjs",
         "deps:graph": "node scripts/generate-dependency-graph.mjs"
     },
     "repository": {

package/repl-codecs.mjs

@@ -0,0 +1,173 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { encodeToWire, decodeWire } from "./codecs/runtime/prefix-codec.mjs";
+import { deriveClosedPattern } from "./codecs/runtime/codec.mjs";
+import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
+import { finalize } from "./codes.mjs";
+
+function isCanonicalCodeName(name) {
+  return typeof name === "string" && name.startsWith("@");
+}
+
+function singletonPatternToCodeHash(pattern) {
+  if (!Array.isArray(pattern) || pattern.length === 0) {
+    return null;
+  }
+
+  const codeDefs = {};
+  for (let i = 0; i < pattern.length; i++) {
+    const [kind, edges] = pattern[i] || [];
+    if (kind !== "closed-product" && kind !== "closed-union") {
+      return null;
+    }
+    if (!Array.isArray(edges)) {
+      throw new Error(`Invalid singleton pattern node ${i}`);
+    }
+
+    const code = kind === "closed-product" ? "product" : "union";
+    codeDefs[`C${i}`] = {
+      code,
+      [code]: Object.fromEntries(edges.map(([label, target]) => {
+        if (!Number.isInteger(target) || target < 0 || target >= pattern.length) {
+          throw new Error(`Invalid singleton pattern edge target ${target}`);
+        }
+        return [label, `C${target}`];
+      }))
+    };
+  }
+
+  return finalize(codeDefs).representatives.C0 || null;
+}
+
+function codeHashToPattern(codeHash, findCode) {
+  const code = findCode(codeHash);
+  if (!code || code.code === "undefined") {
+    throw new Error(`Unknown type '${codeHash}'`);
+  }
+  const resolveType = (name) => {
+    const resolved = findCode(name);
+    if (!resolved || resolved.code === "undefined") {
+      throw new Error(`Unknown type '${name}'`);
+    }
+    return resolved;
+  };
+  return patternToPropertyList(deriveClosedPattern(codeHash, code, resolveType));
+}
+
+function valueForCode(value, codeHash, findCode) {
+  const pattern = codeHashToPattern(codeHash, findCode);
+  return decodeWire(encodeToWire(value, pattern)).value;
+}
+
+function normalizeCodecModule(mod, fallbackName) {
+  const codec = mod.replCodec || mod.codec || mod.default || mod;
+  const name = codec.name || mod.name || fallbackName;
+  const patterns = codec.patterns || (codec.pattern ? [codec.pattern] : null);
+  const codes = codec.codes || codec.codeHashes || (codec.code ? [codec.code] : null) ||
+    patterns?.map((pattern, index) => {
+      const codeHash = singletonPatternToCodeHash(pattern);
+      if (!codeHash) throw new Error(`Codec '${name}' pattern ${index} is not singleton`);
+      return codeHash;
+    });
+  if (!name || typeof name !== "string") {
+    throw new Error("Codec module must export a string name");
+  }
+  if (!Array.isArray(codes) || codes.length === 0) {
+    throw new Error(`Codec '${name}' must export a non-empty codes array`);
+  }
+  if (codec.parse != null && typeof codec.parse !== "function") {
+    throw new Error(`Codec '${name}' parse export must be a function`);
+  }
+  if (codec.print != null && typeof codec.print !== "function") {
+    throw new Error(`Codec '${name}' print export must be a function`);
+  }
+  return {
+    name,
+    codes,
+    parse: codec.parse,
+    print: codec.print
+  };
+}
+
+function codecStore(state) {
+  if (!state.codecs) state.codecs = {};
+  return state.codecs;
+}
+
+function registerCodec(state, codec, source = null) {
+  const registered = [];
+  const store = codecStore(state);
+  for (const codeHash of codec.codes) {
+    if (!isCanonicalCodeName(codeHash)) {
+      throw new Error(`Codec '${codec.name}' has non-canonical code '${codeHash}'`);
+    }
+    if (!store[codeHash]) store[codeHash] = [];
+    const entry = {
+      name: codec.name,
+      source,
+      parse: codec.parse,
+      print: codec.print
+    };
+    const existingIndex = store[codeHash].findIndex((existing) =>
+      existing.name === entry.name && existing.source === entry.source
+    );
+    if (existingIndex === -1) {
+      store[codeHash].push(entry);
+    } else {
+      store[codeHash][existingIndex] = entry;
+    }
+    registered.push({ codeHash, ...entry });
+  }
+  return registered;
+}
+
+async function loadCodecModule(state, filePath) {
+  const resolved = path.resolve(filePath);
+  const url = pathToFileURL(resolved);
+  url.searchParams.set("mtime", String(fs.statSync(resolved).mtimeMs));
+  const mod = await import(url.href);
+  const codec = normalizeCodecModule(mod, path.basename(resolved, path.extname(resolved)));
+  return registerCodec(state, codec, resolved);
+}
+
+function listCodecs(state) {
+  const entries = Object.entries(codecStore(state))
+    .flatMap(([codeHash, codecs]) => codecs.map((codec) => ({ codeHash, ...codec })))
+    .sort((a, b) => a.name.localeCompare(b.name) || a.codeHash.localeCompare(b.codeHash));
+  if (entries.length === 0) return "(none)";
+  return entries.map((entry) => `${entry.name} ${entry.codeHash}${entry.source ? ` (${entry.source})` : ""}`).join("\n");
+}
+
+function codecNames(state, codeHash = null) {
+  const store = codecStore(state);
+  const codecs = codeHash ? (store[codeHash] || []) : Object.values(store).flat();
+  return [...new Set(codecs.map((codec) => codec.name))].sort();
+}
+
+function resolveCodec(state, codeHash, codecName = null, capability = null) {
+  const matches = (codecStore(state)[codeHash] || []).filter((codec) =>
+    (codecName == null || codec.name === codecName) &&
+    (capability == null || typeof codec[capability] === "function")
+  );
+  if (matches.length === 0) {
+    const suffix = codecName ? ` named '${codecName}'` : "";
+    throw new Error(`No ${capability || "usable"} codec${suffix} for ${codeHash}`);
+  }
+  if (matches.length > 1 && codecName == null) {
+    throw new Error(`Multiple codecs for ${codeHash}; specify one of: ${matches.map((codec) => codec.name).join(", ")}`);
+  }
+  return matches[0];
+}
+
+export {
+  codecNames,
+  codeHashToPattern,
+  listCodecs,
+  loadCodecModule,
+  registerCodec,
+  resolveCodec,
+  singletonPatternToCodeHash,
+  valueForCode
+};

package/repl.mjs

@@ -23,15 +23,25 @@ import {
   prettyRelation
 } from "./object.mjs";
 import { propertyListToFilter, valueToK, valueWithEnvelopeToK } from "./codecs/runtime/show-value.mjs";
+import {
+  codecNames,
+  codeHashToPattern,
+  listCodecs,
+  loadCodecModule,
+  resolveCodec,
+  singletonPatternToCodeHash,
+  valueForCode
+} from "./repl-codecs.mjs";
 
 const NAME_RE = /^[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/;
 const TYPE_DEF_RE = /^\s*\$\s*([a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*)\s*=/;
 const REL_DEF_RE = /^\s*([a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*)\s*=/;
 const COMMAND_NAMES = [
   "help", "type", "code", "rel", "def", "run", "eval", "t", "d", "C",
-  "codes", "rels", "val", "reset", "klib", "ko", "load",
+  "codes", "rels", "val", "codec", "input", "reset", "klib", "ko", "load",
   "quit", "exit"
 ];
+const CODEC_COMMAND_NAMES = ["load", "list"];
 const PATH_COMMANDS = new Set(["klib", "ko", "load"]);
 const initialCodes = codes.dump();
 
@@ -50,6 +60,8 @@ function createState() {
     rels: {},
     relAliases: {},
     typeAliases: {},
+    codecs: {},
+    pendingInput: null,
     meta: {},
     value: emptyValue(),
     lastMain: null
@@ -261,8 +273,27 @@ function listAliases(aliases) {
   return entries.map(([name, hash]) => `${name} = ${hash}`).join("\n");
 }
 
-function printValue(value) {
-  return valueWithEnvelopeToK(value);
+function formatCodecOutput(output) {
+  if (Buffer.isBuffer(output)) return output.toString("utf8");
+  return String(output);
+}
+
+function printValue(value, state = null) {
+  const lines = [valueWithEnvelopeToK(value)];
+  if (!state || value === undefined) return lines[0];
+
+  const codeHash = singletonPatternToCodeHash(value.pattern);
+  if (!codeHash) return lines[0];
+
+  for (const codec of state.codecs?.[codeHash] || []) {
+    if (typeof codec.print !== "function") continue;
+    try {
+      lines.push(`${codec.name}: ${formatCodecOutput(codec.print(value, { codeHash, state }))}`);
+    } catch (error) {
+      lines.push(`${codec.name}: <error: ${error.message || String(error)}>`);
+    }
+  }
+  return lines.join("\n");
 }
 
 function commitResult(state, result, lastMain) {
@@ -270,7 +301,7 @@ function commitResult(state, result, lastMain) {
     state.value = result;
     state.lastMain = lastMain;
   }
-  return [printValue(result)];
+  return [printValue(result, state)];
 }
 
 function userDefinedNames(source) {
@@ -348,6 +379,13 @@ function canonicalNames(state) {
   ])].filter((name) => name.startsWith("@")).sort();
 }
 
+function canonicalCodeNames(state) {
+  return [...new Set([
+    ...Object.keys(state.codes),
+    ...Object.values(state.typeAliases)
+  ])].filter((name) => name.startsWith("@")).sort();
+}
+
 function aliasNames(state) {
   return [...new Set([
     ...Object.keys(state.typeAliases),
@@ -397,6 +435,16 @@ function completeCanonical(line, state) {
   return [matches, line];
 }
 
+function completeCanonicalCode(line, state) {
+  const match = line.match(/^(.*?)(@[A-Za-z0-9_?!+-]*)$/);
+  if (!match) return [[], line];
+  const [, prefix, partial] = match;
+  const matches = canonicalCodeNames(state)
+    .filter((name) => name.startsWith(partial))
+    .map((name) => `${prefix}${name}`);
+  return [matches, line];
+}
+
 function completeIdentifier(line, state) {
   const match = line.match(/^(.*?)(\$?[A-Za-z0-9_+-][A-Za-z0-9_?!+-]*)$/);
   if (!match) return [[], line];
@@ -410,6 +458,19 @@ function completeIdentifier(line, state) {
   return [matches, line];
 }
 
+function completeTypeIdentifier(line, state) {
+  const match = line.match(/^(.*?)(\$?[A-Za-z0-9_+-][A-Za-z0-9_?!+-]*)$/);
+  if (!match) return [[], line];
+  const [, prefix, partial] = match;
+  const isTypeToken = partial.startsWith("$");
+  const barePartial = isTypeToken ? partial.slice(1) : partial;
+  const matches = Object.keys(state.typeAliases)
+    .sort()
+    .filter((name) => name.startsWith(barePartial))
+    .map((name) => `${prefix}${isTypeToken ? "$" : ""}${name}`);
+  return [matches, line];
+}
+
 function completePath(line, tokenStart) {
   const token = line.slice(tokenStart);
   const quote = token[0] === "\"" || token[0] === "'" ? token[0] : "";
@@ -468,6 +529,75 @@ function loadPathCompletionStart(argStart, arg) {
   return argStart + restStart + restLeadingWhitespace + completionTokenStart(rest.trimStart());
 }
 
+function completeCommandWord(line, argStart, arg, words) {
+  const leadingWhitespace = arg.length - arg.trimStart().length;
+  const trimmed = arg.trimStart();
+  if (/\s/.test(trimmed)) return [[], line];
+  const prefix = line.slice(0, argStart + leadingWhitespace);
+  const matches = words
+    .filter((word) => word.startsWith(trimmed))
+    .map((word) => `${prefix}${word}`);
+  return [matches, line];
+}
+
+function codecLoadPathCompletionStart(argStart, arg) {
+  const match = arg.match(/^(\s*)load(?:\s+(.*))?$/);
+  if (!match) return null;
+  if (match[2] == null) return null;
+  const [, leading, rest] = match;
+  const restLeadingWhitespace = rest.length - rest.trimStart().length;
+  return argStart + leading.length + "load".length + 1 + restLeadingWhitespace + completionTokenStart(rest.trimStart());
+}
+
+function completeCodecCommand(line, argStart, arg) {
+  const trimmed = arg.trimStart();
+  if (trimmed === "" || !/\s/.test(trimmed)) {
+    return completeCommandWord(line, argStart, arg, CODEC_COMMAND_NAMES);
+  }
+
+  const tokenStart = codecLoadPathCompletionStart(argStart, arg);
+  if (tokenStart == null) return [[], line];
+  return completePath(line, tokenStart);
+}
+
+function resolveTypeHash(state, rawName) {
+  const token = rawName.trim();
+  const bareName = token.startsWith("$") ? token.slice(1) : token;
+  const hash = state.typeAliases[bareName] || (token.startsWith("@") ? token : null);
+  if (!hash || !(hash in state.codes)) throw new Error(`Unknown type '${rawName}'`);
+  return hash;
+}
+
+function completeInputCommand(line, state, argStart, arg) {
+  const match = arg.match(/^(\s*)(\S+)?(\s+)?(\S*)?$/);
+  if (!match) return [[], line];
+  const [, leading, typeToken = "", afterTypeWhitespace = "", codecPartial = ""] = match;
+
+  if (!typeToken || !afterTypeWhitespace) {
+    if (/@[A-Za-z0-9_?!+-]*$/.test(line)) return completeCanonicalCode(line, state);
+    return completeTypeIdentifier(line, state);
+  }
+
+  if (typeToken) {
+    const prefix = line.slice(0, argStart + leading.length + typeToken.length + afterTypeWhitespace.length);
+    const names = (() => {
+      try {
+        return codecNames(state, resolveTypeHash(state, typeToken));
+      } catch {
+        return codecNames(state);
+      }
+    })();
+    return [
+      names
+        .filter((name) => name.startsWith(codecPartial))
+        .map((name) => `${prefix}${name}`),
+      line
+    ];
+  }
+
+  return [[], line];
+}
+
 function completeCommandArgument(line, state) {
   const body = line.slice(1);
   const firstSpace = body.search(/\s/);
@@ -477,6 +607,14 @@ function completeCommandArgument(line, state) {
   const argStart = 1 + firstSpace + 1;
   const arg = line.slice(argStart);
 
+  if (command === "codec") {
+    return completeCodecCommand(line, argStart, arg);
+  }
+
+  if (command === "input") {
+    return completeInputCommand(line, state, argStart, arg);
+  }
+
   if (PATH_COMMANDS.has(command)) {
     const tokenStart = command === "load"
       ? loadPathCompletionStart(argStart, arg)
@@ -714,7 +852,59 @@ async function runSnippet(input, state, options = {}) {
   return commitResult(state, result, snippet);
 }
 
+async function loadCodec(input, state) {
+  const [subcommand, ...rest] = input.trim().split(/\s+/);
+  switch (subcommand) {
+    case "load": {
+      const filePath = rest.join(" ");
+      if (!filePath) throw new Error(":codec load requires a file path");
+      const registered = await loadCodecModule(state, expandHome(filePath));
+      return registered.map(({ name, codeHash }) => `loaded codec ${name} for ${codeHash}`);
+    }
+    case "list":
+      if (rest.length > 0) throw new Error(":codec list does not accept arguments");
+      return [listCodecs(state)];
+    default:
+      throw new Error(":codec requires 'load' or 'list'");
+  }
+}
+
+async function requestCodecInput(input, state) {
+  const parts = input.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0 || parts.length > 2) {
+    throw new Error(":input requires a singleton type and optional codec name");
+  }
+
+  const codeHash = resolveTypeHash(state, parts[0]);
+  const codecName = parts[1] || null;
+  resolveCodec(state, codeHash, codecName, "parse");
+  state.pendingInput = { codeHash, codecName };
+  return [`input ${codeHash}${codecName ? ` using ${codecName}` : ""}: enter value text`];
+}
+
+async function consumeCodecInput(input, state) {
+  const pending = state.pendingInput;
+  if (!pending) return null;
+  state.pendingInput = null;
+
+  restoreCodes(state);
+  const codec = resolveCodec(state, pending.codeHash, pending.codecName, "parse");
+  const pattern = codeHashToPattern(pending.codeHash, codes.find);
+  const parsed = await codec.parse(input, {
+    codeHash: pending.codeHash,
+    pattern,
+    state
+  });
+  const value = valueForCode(parsed, pending.codeHash, codes.find);
+  state.value = value;
+  return [printValue(value, state)];
+}
+
 async function evaluateInput(input, state) {
+  if (state.pendingInput) {
+    return consumeCodecInput(input, state);
+  }
+
   const line = input.trim();
   if (line === "" || line.startsWith("#") || line.startsWith("//") || line.startsWith("--")) return [];
 
@@ -764,9 +954,13 @@ async function evaluateCommand(line, state) {
       return [listAliases(state.relAliases)];
     case "val":
       return [
-        printValue(state.value),
+        printValue(state.value, state),
         JSON.stringify(state.value, null, 2)
       ];
+    case "codec":
+      return loadCodec(arg, state);
+    case "input":
+      return requestCodecInput(arg, state);
     case "reset": {
       const fresh = createState();
       Object.assign(state, fresh);
@@ -845,6 +1039,9 @@ function helpText() {
     ":type name           show type definition",
     ":codes               list type aliases",
     ":rels                list relation aliases",
+    ":codec load file     load a REPL codec module",
+    ":codec list          list loaded codecs",
+    ":input type [codec]  read next line as codec input",
     ":load [--no-alias] file",
     "                     load .k source or .klib",
     ":klib file           export state as a library",
@@ -884,6 +1081,19 @@ function startRepl() {
   console.log("k interpreter (.klib-backed). Type :help for commands.");
   rl.prompt();
   async function handleLine(line) {
+    if (state.pendingInput && buffer.length === 0) {
+      rl.setPrompt("> ");
+      try {
+        for (const output of await consumeCodecInput(line, state)) {
+          console.log(output);
+        }
+      } catch (error) {
+        console.error(error.message || String(error));
+      }
+      if (!closed) rl.prompt();
+      return;
+    }
+
     if (lineHasExplicitContinuation(line)) {
       buffer.push(lineForContinuation(line));
       rl.setPrompt("  ");

package/run.mjs

@@ -122,6 +122,20 @@ function constrainWithPattern(value, constraint, exp) {
   return withPattern(value, pattern);
 }
 
+function projectionPattern(staticOutputPattern, valuePattern, label, exp) {
+  const dynamicOutputPattern = edgeSubpattern(valuePattern, label);
+  const pattern = intersectPatterns(staticOutputPattern, dynamicOutputPattern);
+  if (!pattern && staticOutputPattern && dynamicOutputPattern) {
+    throw new TypeError(
+      `Type Error in '${exp.op}'${expLocation(exp)}\n` +
+      ` - Projected value envelope does not intersect expression output pattern.\n` +
+      ` - output pattern: ${patternPreview(staticOutputPattern)}\n` +
+      ` - projected envelope: ${patternPreview(dynamicOutputPattern)}`
+    );
+  }
+  return pattern;
+}
+
 function compiledExp(findCode, exp, typePatternGraph) {
   const cached = exp._compiledRun;
   if (cached?.findCode === findCode && cached?.typePatternGraph === typePatternGraph && cached?.defs === run.defs) {
@@ -188,13 +202,13 @@ function compiledExp(findCode, exp, typePatternGraph) {
     case "dot":
       fn = (value) => {
         if (value === undefined) return undefined;
-        return withPattern(value.product[exp.dot], staticOutputPattern || edgeSubpattern(value.pattern, exp.dot));
+        return withPattern(value.product[exp.dot], projectionPattern(staticOutputPattern, value.pattern, exp.dot, exp));
       };
       break;
     case "div":
       fn = (value) => {
         if (value === undefined || value.tag !== exp.div) return undefined;
-        return withPattern(value.value, staticOutputPattern || edgeSubpattern(value.pattern, exp.div));
+        return withPattern(value.value, projectionPattern(staticOutputPattern, value.pattern, exp.div, exp));
       };
       break;
     case "comp": {

package/scripts/benchmark-idempotency.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { performance } from "node:perf_hooks";
+
+const DEFAULT_EXAMPLES = [
+  "Examples/nat.k",
+  "Examples/byte.k",
+  "Examples/bnat.k",
+  "Examples/arithmetics.k",
+  "Examples/ieee.k"
+];
+
+const iterations = Number(process.env.K_BENCH_ITERATIONS || 5);
+const examples = process.argv.slice(2);
+const benchmarkExamples = examples.length > 0 ? examples : DEFAULT_EXAMPLES;
+
+function run(args) {
+  const result = spawnSync("node", args, {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.status !== 0) {
+    throw new Error(`${args.join(" ")} failed\n${result.stderr || result.stdout}`);
+  }
+}
+
+function median(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.floor(sorted.length / 2)];
+}
+
+function formatMs(value) {
+  return `${Math.round(value)} ms`;
+}
+
+function formatBytes(value) {
+  if (value >= 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(1)} MiB`;
+  if (value >= 1024) return `${Math.round(value / 1024)} KiB`;
+  return `${value} B`;
+}
+
+console.log(`compile-lib/decompile round-trip benchmark (${iterations} iterations)`);
+console.log("example, median, min, max, object");
+
+for (const example of benchmarkExamples) {
+  const times = [];
+  let size = 0;
+
+  for (let i = 0; i < iterations; i++) {
+    const out = mkdtempSync(join(tmpdir(), `k-idempotency-bench-${example.replaceAll("/", "_")}-`));
+    const t0 = performance.now();
+    run(["objects/compile-lib.mjs", example, join(out, "1.klib")]);
+    run(["objects/decompile.mjs", join(out, "1.klib"), join(out, "1.k")]);
+    run(["objects/compile-lib.mjs", join(out, "1.k"), join(out, "2.klib")]);
+    run(["objects/decompile.mjs", join(out, "2.klib"), join(out, "2.k")]);
+    times.push(performance.now() - t0);
+    size = statSync(join(out, "1.klib")).size;
+  }
+
+  console.log([
+    example,
+    formatMs(median(times)),
+    formatMs(Math.min(...times)),
+    formatMs(Math.max(...times)),
+    formatBytes(size)
+  ].join(", "));
+}