@fraczak/k 6.3.2 → 6.3.3

package/DOCS/REPL.md

@@ -47,7 +47,7 @@ complete.
 | `:rels` | List relation aliases |
 | `:codec load file` | Load an importable REPL codec module |
 | `:codec list` | List loaded REPL codecs |
-| `:input type [codec]` | Read the next line as codec input for a singleton type |
+| `:input type [codec]` | Read the next line as codec input for a type |
 | `:load [--no-alias] file` | Load `.k` source or `.klib` into the current state |
 | `:klib file` | Export the active relation closure as a `.klib` library |
 | `:ko file expr` | Export a `.ko` executable with `expr` as main |
@@ -139,7 +139,7 @@ Tab completion covers:
 Type aliases also complete in `$name` position inside raw k input.
 
 For codec commands, completion covers `:codec load`, `:codec list`, file paths
-after `:codec load`, singleton type names after `:input`, and loaded codec names
+after `:codec load`, type names after `:input`, and loaded codec names
 after the input type.
 
 ## Loading
@@ -158,8 +158,10 @@ unless `--no-alias` is used.
 
 ## Codecs
 
-REPL codecs are keyed by canonical singleton code hashes. Open filters are not
-used for codec dispatch.
+REPL codecs are usually keyed by canonical code hashes. Patterns are not used
+for codec dispatch. A codec may also export `universal = true` to make it
+available for any type selected by `:input`; the parsed value is still validated
+against the requested type before it enters the session.
 
 ### `:codec load file`
 
@@ -172,15 +174,18 @@ export function parse(text) { /* text -> Value */ }
 export function print(value) { /* Value -> text */ }
 ```
 
-A codec may export `patterns` instead of `codes`; each pattern must be a
-singleton closed property-list pattern, and its code hash is recalculated by the
-REPL.
+A codec may export `patterns` instead of `codes`; each pattern must be a closed
+property-list pattern that can be canonicalized to a code hash, and that hash is
+recalculated by the REPL. A universal codec exports `universal = true` instead
+of `codes` or `patterns`.
 
 ### `:input type [codec]`
 
-Resolves `type` to a canonical singleton code, selects the registered codec,
-and consumes the next line verbatim as codec input. The parsed value is validated
-against that code before becoming the current value.
+Resolves `type` to a canonical code hash, selects the registered codec, and
+consumes the next line verbatim as codec input. `type` may be a type alias, a
+canonical code hash, or an inline type expression such as
+`<{} true, {} false>`. The parsed value is validated against that type before
+becoming the current value.
 
 ## Export
 

package/codecs/json.mjs

@@ -5,6 +5,9 @@ import { decodeWire, encodeToWire } from "./runtime/prefix-codec.mjs";
 import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
 import { fromJsonValue, toJsonValue, patternFromJsonValue } from "./json-codec.mjs";
 
+const name = "json";
+const universal = true;
+
 function usage(stream = console.error) {
   stream(`Usage: ${argv[1]} --parse | --print`);
   stream("  --parse      Read JSON from stdin, write binary pattern+value stream.");
@@ -21,6 +24,14 @@ function readAll(stream) {
   });
 }
 
+function parse(text) {
+  return fromJsonValue(JSON.parse(text));
+}
+
+function print(value) {
+  return JSON.stringify(toJsonValue(value));
+}
+
 async function main() {
   const args = argv.slice(2);
   if (args.includes("-h") || args.includes("--help")) {
@@ -36,12 +47,13 @@ async function main() {
   const buf = await readAll(stdin);
 
   if (args[0] === "--parse") {
-    const json = JSON.parse(buf.toString("utf8"));
+    const text = buf.toString("utf8");
+    const json = JSON.parse(text);
     const value = fromJsonValue(json);
     stdout.write(encodeToWire(value, patternFromJsonValue(json)));
   } else {
     const { value } = decodeWire(buf);
-    stdout.write(`${JSON.stringify(toJsonValue(value))}\n`);
+    stdout.write(`${print(value)}\n`);
   }
 }
 
@@ -51,3 +63,5 @@ if (isMainEntrypoint(import.meta.url, argv[1])) {
     exit(1);
   });
 }
+
+export { name, universal, parse, print };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.3.2",
+    "version": "6.3.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": {

package/repl-codecs.mjs

@@ -7,11 +7,13 @@ import { deriveClosedPattern } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
 import { finalize } from "./codes.mjs";
 
+const UNIVERSAL_CODE = "*";
+
 function isCanonicalCodeName(name) {
   return typeof name === "string" && name.startsWith("@");
 }
 
-function singletonPatternToCodeHash(pattern) {
+function closedPatternToCodeHash(pattern) {
   if (!Array.isArray(pattern) || pattern.length === 0) {
     return null;
   }
@@ -23,7 +25,7 @@ function singletonPatternToCodeHash(pattern) {
       return null;
     }
     if (!Array.isArray(edges)) {
-      throw new Error(`Invalid singleton pattern node ${i}`);
+      throw new Error(`Invalid closed pattern node ${i}`);
     }
 
     const code = kind === "closed-product" ? "product" : "union";
@@ -31,7 +33,7 @@ function singletonPatternToCodeHash(pattern) {
       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}`);
+          throw new Error(`Invalid closed pattern edge target ${target}`);
         }
         return [label, `C${target}`];
       }))
@@ -64,17 +66,18 @@ function valueForCode(value, codeHash, findCode) {
 function normalizeCodecModule(mod, fallbackName) {
   const codec = mod.replCodec || mod.codec || mod.default || mod;
   const name = codec.name || mod.name || fallbackName;
+  const universal = codec.universal === true;
   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`);
+      const codeHash = closedPatternToCodeHash(pattern);
+      if (!codeHash) throw new Error(`Codec '${name}' pattern ${index} must be a closed property-list pattern`);
       return codeHash;
     });
   if (!name || typeof name !== "string") {
     throw new Error("Codec module must export a string name");
   }
-  if (!Array.isArray(codes) || codes.length === 0) {
+  if (!universal && (!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") {
@@ -85,7 +88,8 @@ function normalizeCodecModule(mod, fallbackName) {
   }
   return {
     name,
-    codes,
+    codes: universal ? [UNIVERSAL_CODE] : codes,
+    universal,
     parse: codec.parse,
     print: codec.print
   };
@@ -100,13 +104,15 @@ function registerCodec(state, codec, source = null) {
   const registered = [];
   const store = codecStore(state);
   for (const codeHash of codec.codes) {
-    if (!isCanonicalCodeName(codeHash)) {
+    const universal = codeHash === UNIVERSAL_CODE;
+    if (!universal && !isCanonicalCodeName(codeHash)) {
       throw new Error(`Codec '${codec.name}' has non-canonical code '${codeHash}'`);
     }
     if (!store[codeHash]) store[codeHash] = [];
     const entry = {
       name: codec.name,
       source,
+      universal,
       parse: codec.parse,
       print: codec.print
     };
@@ -137,20 +143,27 @@ function listCodecs(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");
+  return entries.map((entry) => `${entry.name} ${entry.codeHash === UNIVERSAL_CODE ? "all" : 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();
+  const codecs = codeHash
+    ? [...(store[codeHash] || []), ...(store[UNIVERSAL_CODE] || [])]
+    : 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) =>
+  const store = codecStore(state);
+  const matchesCodec = (codec) =>
     (codecName == null || codec.name === codecName) &&
-    (capability == null || typeof codec[capability] === "function")
-  );
+    (capability == null || typeof codec[capability] === "function");
+  const exactMatches = (store[codeHash] || []).filter(matchesCodec);
+  const universalMatches = (store[UNIVERSAL_CODE] || []).filter(matchesCodec);
+  const matches = codecName == null && exactMatches.length > 0
+    ? exactMatches
+    : [...exactMatches, ...universalMatches];
   if (matches.length === 0) {
     const suffix = codecName ? ` named '${codecName}'` : "";
     throw new Error(`No ${capability || "usable"} codec${suffix} for ${codeHash}`);
@@ -168,6 +181,7 @@ export {
   loadCodecModule,
   registerCodec,
   resolveCodec,
-  singletonPatternToCodeHash,
+  closedPatternToCodeHash,
+  UNIVERSAL_CODE,
   valueForCode
 };

package/repl.mjs

@@ -29,7 +29,8 @@ import {
   listCodecs,
   loadCodecModule,
   resolveCodec,
-  singletonPatternToCodeHash,
+  closedPatternToCodeHash,
+  UNIVERSAL_CODE,
   valueForCode
 } from "./repl-codecs.mjs";
 
@@ -43,6 +44,7 @@ const COMMAND_NAMES = [
 ];
 const CODEC_COMMAND_NAMES = ["load", "list"];
 const PATH_COMMANDS = new Set(["klib", "ko", "load"]);
+const INPUT_TYPE_NAME = "__input__";
 const initialCodes = codes.dump();
 
 function cloneJSON(value) {
@@ -323,14 +325,19 @@ function printValue(value, state = null) {
   const lines = [valueWithEnvelopeToK(value)];
   if (!state || value === undefined) return lines[0];
 
-  const codeHash = singletonPatternToCodeHash(value.pattern);
+  const codeHash = closedPatternToCodeHash(value.pattern);
   if (!codeHash) return lines[0];
 
-  for (const codec of state.codecs?.[codeHash] || []) {
+  const codecs = [
+    ...(state.codecs?.[codeHash] || []),
+    ...(state.codecs?.[UNIVERSAL_CODE] || [])
+  ];
+  for (const codec of codecs) {
     if (typeof codec.print !== "function") continue;
     try {
       lines.push(`${codec.name}: ${formatCodecOutput(codec.print(value, { codeHash, state }))}`);
     } catch (error) {
+      if (codec.universal) continue;
       lines.push(`${codec.name}: <error: ${error.message || String(error)}>`);
     }
   }
@@ -609,6 +616,40 @@ function resolveTypeHash(state, rawName) {
   return hash;
 }
 
+function isSimpleTypeReference(rawType) {
+  return /^\$?[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/.test(rawType.trim());
+}
+
+function resolveTypeExpressionHash(state, rawType) {
+  restoreCodes(state);
+  const preamble = aliasPreamble(state, INPUT_TYPE_NAME);
+  const source = [
+    preamble,
+    ensureSemicolon(`$ ${INPUT_TYPE_NAME} = ${rawType.trim()}`),
+    "()"
+  ].filter(Boolean).join("\n");
+
+  try {
+    const annotated = annotate(source, { libraries: [stateLibrary(state)] });
+    const hash = annotated.representatives[INPUT_TYPE_NAME];
+    if (!hash) throw new Error(":input type expression did not produce a code hash");
+    state.codes = codes.dump();
+    return hash;
+  } catch (error) {
+    restoreCodes(state);
+    throw remapError(error, preambleLineCount(preamble));
+  }
+}
+
+function resolveInputTypeHash(state, rawType) {
+  try {
+    return resolveTypeHash(state, rawType);
+  } catch (error) {
+    if (isSimpleTypeReference(rawType)) throw error;
+  }
+  return resolveTypeExpressionHash(state, rawType);
+}
+
 function completeInputCommand(line, state, argStart, arg) {
   const match = arg.match(/^(\s*)(\S+)?(\s+)?(\S*)?$/);
   if (!match) return [[], line];
@@ -900,7 +941,9 @@ async function loadCodec(input, state) {
       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}`);
+      return registered.map(({ name, codeHash }) =>
+        `loaded codec ${name} for ${codeHash === UNIVERSAL_CODE ? "all types" : codeHash}`
+      );
     }
     case "list":
       if (rest.length > 0) throw new Error(":codec list does not accept arguments");
@@ -911,15 +954,28 @@ async function loadCodec(input, state) {
 }
 
 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 trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error(":input requires a 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 };
+  let codeHash;
+  let codecName = null;
+  try {
+    codeHash = resolveInputTypeHash(state, trimmed);
+  } catch (wholeError) {
+    const split = trimmed.match(/^(.*\S)\s+([a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*)$/);
+    if (!split) throw wholeError;
+    try {
+      codeHash = resolveInputTypeHash(state, split[1]);
+      codecName = split[2];
+    } catch (typeError) {
+      throw typeError;
+    }
+  }
+
+  const codec = resolveCodec(state, codeHash, codecName, "parse");
+  state.pendingInput = { codeHash, codecName, promptName: codec.name };
   return [`input ${codeHash}${codecName ? ` using ${codecName}` : ""}: enter value text`];
 }
 
@@ -1097,6 +1153,11 @@ function helpText() {
   ].join("\n");
 }
 
+function promptForState(state) {
+  const promptName = state.pendingInput?.promptName;
+  return promptName ? `${promptName}> ` : "> ";
+}
+
 function cliUsage() {
   console.log("Usage: k-repl");
   console.log("       k-repl -h");
@@ -1151,6 +1212,7 @@ function startRepl() {
       } catch (error) {
         console.error(error.message || String(error));
       }
+      rl.setPrompt(promptForState(state));
       if (!closed) rl.prompt();
       return;
     }
@@ -1223,6 +1285,7 @@ export {
   lineHasExplicitContinuation,
   lineTerminatesSnippet,
   printValue,
+  promptForState,
   propertyListToFilter,
   valueToK
 };

package/tests/test-ieee-arithmetic.mjs

@@ -4,7 +4,7 @@ import { createState, evaluateInput } from "../repl.mjs";
 import { Value, isProduct } from "../Value.mjs";
 import codes from "../codes.mjs";
 import { parse as parseFloat64, print as printFloat64 } from "../codecs/ieee.mjs";
-import { singletonPatternToCodeHash, valueForCode } from "../repl-codecs.mjs";
+import { closedPatternToCodeHash, valueForCode } from "../repl-codecs.mjs";
 
 const state = createState();
 await evaluateInput(":load Examples/ieee.k", state);
@@ -40,7 +40,7 @@ async function runProjectedResult(op, x, y) {
 }
 
 function assertFloatResult(value, expected, label) {
-  assert.equal(singletonPatternToCodeHash(value.pattern), float64Hash, `${label}: result should keep float64 envelope`);
+  assert.equal(closedPatternToCodeHash(value.pattern), float64Hash, `${label}: result should keep float64 envelope`);
   assert.equal(printFloat64(value), expected, label);
 }
 

package/tests/test-repl.mjs

@@ -15,7 +15,8 @@ import {
   helpText,
   isMainEntrypoint,
   lineHasExplicitContinuation,
-  lineTerminatesSnippet
+  lineTerminatesSnippet,
+  promptForState
 } from "../repl.mjs";
 import { decodeObject, objectToFunction } from "../object.mjs";
 import { Value } from "../Value.mjs";
@@ -194,6 +195,36 @@ assert.equal(output[0], `input ${utf8State.typeAliases.string} using utf8: enter
 output = await evaluateInput("hello", utf8State);
 assert.match(output[0], /utf8: hello/);
 
+const jsonState = createState();
+output = await evaluateInput(":type bool = <{} true, {} false>", jsonState);
+assert.match(output[0], /^\$ bool = @/);
+output = await evaluateInput(":codec load ./codecs/json.mjs", jsonState);
+assert.equal(output[0], "loaded codec json for all types");
+output = await evaluateInput(":codec list", jsonState);
+assert.match(output[0], /^json all /);
+completions = completeInput(":input bool j", jsonState)[0];
+assert(completions.includes(":input bool json"));
+output = await evaluateInput(":input bool", jsonState);
+assert.equal(output[0], `input ${jsonState.typeAliases.bool}: enter value text`);
+assert.equal(promptForState(jsonState), "json> ");
+output = await evaluateInput("true", jsonState);
+assert.match(output[0], /\{\}\|true \?</);
+assert.match(output[0], /json: true/);
+assert.equal(promptForState(jsonState), "> ");
+output = await evaluateInput(":input <{}true,{}false>", jsonState);
+assert.equal(output[0], `input ${jsonState.typeAliases.bool}: enter value text`);
+assert.equal(promptForState(jsonState), "json> ");
+output = await evaluateInput("false", jsonState);
+assert.match(output[0], /\{\}\|false \?</);
+assert.match(output[0], /json: false/);
+assert.equal(promptForState(jsonState), "> ");
+output = await evaluateInput(":input {bool left, bool right} json", jsonState);
+assert.match(output[0], /^input @[^ ]+ using json: enter value text$/);
+assert.equal(promptForState(jsonState), "json> ");
+output = await evaluateInput('{"left":true,"right":false}', jsonState);
+assert.match(output[0], /json: \{"left":true,"right":false\}/);
+assert.equal(promptForState(jsonState), "> ");
+
 const replPath = fileURLToPath(new URL("../repl.mjs", import.meta.url));
 try {
   fs.rmSync(symlinkPath, { force: true });