@fraczak/k 6.7.0 → 6.9.0

package/repl.mjs

@@ -14,10 +14,12 @@ import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
 import codes from "./codes.mjs";
 import { Value, isProduct, isVariant } from "./Value.mjs";
+import { patternFromFilter } from "./codecs/runtime/pattern-k.mjs";
 if (typeof globalThis !== "undefined") {
   globalThis.Value = Value;
   globalThis.isProduct = isProduct;
   globalThis.isVariant = isVariant;
+  globalThis.patternFromFilter = patternFromFilter;
 }
 import { patterns2filters, prettyCode, prettyRel } from "./pretty.mjs";
 import {
@@ -36,26 +38,22 @@ import {
   codeHashToPattern,
   listCodecs,
   loadCodecModule,
-  normalizeCodecModule,
   registerCodec,
   resolveCodec,
   unregisterCodec,
-  BUILTIN_CODECS,
   closedPatternToCodeHash,
-  UNIVERSAL_CODE,
-  valueForCode
+  valueForPattern,
+  ensureEnveloped
 } 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", "codecs", "rels", "val", "codec", "input", "reset", "klib", "ko", "load",
-  "timing", "time",
+  "help", "type", "code", "run", "eval", "t", "d", "C",
+  "codes", "codecs", "rels", "codec", "input", "reset", "klib", "ko", "load",
+  "time",
   "quit", "exit"
 ];
-const CODEC_COMMAND_NAMES = ["load", "unload", "list", "define"];
+const CODEC_COMMAND_NAMES = ["load", "unload", "list"];
 const PATH_COMMANDS = new Set(["klib", "ko", "load"]);
 const INPUT_TYPE_NAME = "__input__";
 const initialCodes = codes.dump();
@@ -90,7 +88,7 @@ function createState() {
     lastResult: null,
     lastMain: null,
     lastTiming: null,
-    showTiming: false
+    showTiming: true
   };
 }
 
@@ -351,7 +349,8 @@ function listAliases(aliases) {
 }
 
 function formatCodecOutput(output) {
-  if (Buffer.isBuffer(output)) return output.toString("utf8");
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(output)) return output.toString("utf8");
+  if (typeof Uint8Array !== "undefined" && output instanceof Uint8Array) return new TextDecoder().decode(output);
   return String(output);
 }
 
@@ -359,20 +358,16 @@ function printValue(value, state = null) {
   const lines = [valueWithEnvelopeToK(value)];
   if (!state || value === undefined) return lines[0];
 
-  const codeHash = closedPatternToCodeHash(value.pattern);
-  if (!codeHash) return lines[0];
-
-  const codecs = [
-    ...(state.codecs?.[codeHash] || []),
-    ...(state.codecs?.[UNIVERSAL_CODE] || [])
-  ];
-  for (const codec of codecs) {
+  const store = state.codecs || {};
+  for (const codec of Object.values(store)) {
     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)}>`);
+      const output = codec.print(value, { state });
+      if (output != null) {
+        lines.push(`${codec.name}: ${formatCodecOutput(output)}`);
+      }
+    } catch {
+      // Codec cannot format this value; silently skip
     }
   }
   return lines.join("\n");
@@ -652,25 +647,19 @@ function completeCodecCommand(line, argStart, arg, state) {
   const tokenStart = codecLoadPathCompletionStart(argStart, arg);
   if (tokenStart == null) return [[], line];
   const [pathMatches] = completePath(line, tokenStart);
-  const match = arg.match(/^(\s*)load(?:\s+(.*))?$/);
-  const partial = match && match[2] != null ? match[2].trim() : "";
-  const prefix = line.slice(0, tokenStart);
-  const builtinMatches = ["int", "utf8", "json", "ieee"]
-    .filter((name) => name.startsWith(partial))
-    .map((name) => `${prefix}${name}`);
-  return [[...builtinMatches, ...pathMatches], line];
+  return [pathMatches, line];
 }
 
 function resolveTypeHash(state, rawName) {
   const token = rawName.trim();
-  const bareName = token.startsWith("$") ? token.slice(1) : token;
+  const bareName = token.startsWith("$") ? token.slice(1).trim() : 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 isSimpleTypeReference(rawType) {
-  return /^\$?[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/.test(rawType.trim());
+  return /^\$?\s*[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/.test(rawType.trim());
 }
 
 function resolveTypeExpressionHash(state, rawType) {
@@ -703,33 +692,101 @@ function resolveInputTypeHash(state, rawType) {
   return resolveTypeExpressionHash(state, rawType);
 }
 
-function completeInputCommand(line, state, argStart, arg) {
-  const match = arg.match(/^(\s*)(\S+)?(\s+)?(\S*)?$/);
-  if (!match) return [[], line];
-  const [, leading, typeToken = "", afterTypeWhitespace = "", codecPartial = ""] = match;
+function resolvePatternExpression(state, patternExpr) {
+  restoreCodes(state);
+  const preamble = aliasPreamble(state);
+  const source = [
+    preamble,
+    patternExpr
+  ].filter(Boolean).join("\n");
+  try {
+    const annotated = annotate(source, { libraries: [stateLibrary(state)] });
+    const mainRel = annotated.rels.__main__;
+    if (!mainRel || !mainRel.typePatternGraph) {
+      throw new Error(`Invalid pattern expression '${patternExpr}'`);
+    }
+    if (mainRel.def.op !== "filter" && mainRel.def.op !== "code") {
+      throw new Error(`Expected a pattern expression, got ${mainRel.def.op}`);
+    }
+    const rootPatternId = mainRel.typePatternGraph.find(mainRel.def.patterns[0]);
+    const pattern = patternToPropertyList(exportPatternGraph(mainRel.typePatternGraph, rootPatternId));
+    const codeHash = closedPatternToCodeHash(pattern);
+    state.codes = codes.dump();
+    return { pattern, codeHash, display: codeHash || patternExpr };
+  } catch (error) {
+    restoreCodes(state);
+    throw remapError(error, preambleLineCount(preamble));
+  }
+}
 
-  if (!typeToken || !afterTypeWhitespace) {
-    if (/@[A-Za-z0-9_?!+-]*$/.test(line)) return completeCanonicalCode(line, state);
-    return completeTypeIdentifier(line, state);
+function resolveInputPattern(state, rawExpr) {
+  const token = (rawExpr || "").trim();
+  if (!token || token === "*" || token === "(...)") {
+    return { pattern: [["any", []]], codeHash: null, display: "(...)" };
   }
 
-  if (typeToken) {
-    const prefix = line.slice(0, argStart + leading.length + typeToken.length + afterTypeWhitespace.length);
-    const names = (() => {
+  // 1. Explicit filter / pattern expression
+  if (token.startsWith("?")) {
+    const res = resolvePatternExpression(state, token);
+    return { ...res, display: token };
+  }
+
+  // 2. Pattern as type prefixed by dollar: $ name, $ {typeExpr}, $ <typeExpr>
+  if (token.startsWith("$")) {
+    const bare = token.slice(1).trim();
+    if (bare in (state.typeAliases || {})) {
+      const hash = state.typeAliases[bare];
+      const pattern = codeHashToPattern(hash, (h) => state.codes?.[h] || codes.find(h));
+      return { pattern, codeHash: hash, display: `$ ${bare}` };
+    }
+    try {
+      const res = resolvePatternExpression(state, `? ${token}`);
+      return { ...res, display: token };
+    } catch {}
+  }
+
+  // 3. Known type alias or canonical code hash
+  try {
+    const hash = resolveTypeHash(state, token);
+    const pattern = codeHashToPattern(hash, (h) => state.codes?.[h] || codes.find(h));
+    return { pattern, codeHash: hash, display: hash };
+  } catch (aliasErr) {
+    if (isSimpleTypeReference(token)) {
       try {
-        return codecNames(state, resolveTypeHash(state, typeToken));
-      } catch {
-        return codecNames(state);
-      }
-    })();
-    return [
-      names
-        .filter((name) => name.startsWith(codecPartial))
-        .map((name) => `${prefix}${name}`),
-      line
-    ];
+        const res = resolvePatternExpression(state, `? ${token}`);
+        return { ...res, display: token };
+      } catch {}
+      throw aliasErr;
+    }
   }
 
+  // 4. Composite expression ({...}, <...>): try type expression first
+  try {
+    const hash = resolveTypeExpressionHash(state, token);
+    const pattern = codeHashToPattern(hash, (h) => state.codes?.[h] || codes.find(h));
+    return { pattern, codeHash: hash, display: hash };
+  } catch (typeErr) {
+    // 5. Fall back to pattern expression: ? <expr>
+    try {
+      const res = resolvePatternExpression(state, `? ${token}`);
+      return { ...res, display: token };
+    } catch {
+      throw typeErr;
+    }
+  }
+}
+
+function completeInputCommand(line, state, argStart, arg) {
+  const match = arg.match(/^(\s*)(\S*)$/);
+  if (match) {
+    const [, leading, partial] = match;
+    const prefix = line.slice(0, argStart + leading.length);
+    const names = codecNames(state);
+    const matches = names
+      .filter((name) => name.startsWith(partial))
+      .map((name) => `${prefix}${name}`);
+    return [matches, line];
+  }
   return [[], line];
 }
 
@@ -819,14 +876,6 @@ function parseLoadArgs(arg, usagePrefix = ":") {
   return { path: arg.trim(), loadAliases: true };
 }
 
-const CODEC_FILES = {
-  int: "arithmetics.k",
-  utf8: "core.k",
-  json: "core.k",
-  ieee: "ieee.k",
-  unit: "core.k"
-};
-
 function normalizeFilePath(p) {
   return p.replace(/\\/g, "/").replace(/^\.\//, "");
 }
@@ -897,24 +946,6 @@ function loadSourceOrKlib(state, targetPath, options = {}) {
   return targetPath;
 }
 
-function ensureCodecDependencies(state, codecTarget) {
-  const norm = normalizeFilePath(codecTarget).toLowerCase();
-  const base = path.basename(norm, path.extname(norm));
-  const depFile = CODEC_FILES[base] || CODEC_FILES[norm];
-  if (!depFile) return null;
-  if (!state.loadedFiles) state.loadedFiles = new Set();
-  const depNormKey = normalizeFilePath(depFile);
-  const baseName = path.basename(depNormKey);
-  const alreadyLoaded = state.loadedFiles.has(depNormKey) ||
-    state.loadedFiles.has(`Examples/${depNormKey}`) ||
-    Array.from(state.loadedFiles).some(f => path.basename(f) === baseName);
-  if (!alreadyLoaded) {
-    loadSourceOrKlib(state, depFile);
-    return depFile;
-  }
-  return null;
-}
-
 function lineForContinuation(line) {
   return line.replace(/\\\s*$/, "");
 }
@@ -981,57 +1012,6 @@ function compileSnippetArtifacts(source, state, sourceName = "<repl>") {
   }
 }
 
-async function defineType(input, state) {
-  const typeMatch = input.match(TYPE_DEF_RE);
-  if (!typeMatch) {
-    throw new Error("Type definitions use: :type name = <...>");
-  }
-
-  const name = typeMatch[1];
-  restoreCodes(state);
-  const preamble = aliasPreamble(state, name);
-  const source = [preamble, ensureSemicolon(input), "()"].filter(Boolean).join("\n");
-  let annotated;
-  try {
-    annotated = annotate(source, { libraries: [stateLibrary(state)] });
-  } catch (error) {
-    throw remapError(error, preambleLineCount(preamble));
-  }
-  const hash = annotated.representatives[name];
-  if (!hash) throw new Error(`Type definition did not produce an alias for '${name}'`);
-  state.codes = codes.dump();
-  state.typeAliases[name] = hash;
-  rememberOrigin(state, hash, name, "code");
-  return [`$ ${name} = ${hash}`];
-}
-
-async function defineRelation(input, state) {
-  const relMatch = input.match(REL_DEF_RE);
-  if (!relMatch) {
-    throw new Error("Relation definitions use: :rel name = expression");
-  }
-
-  const name = relMatch[1];
-  restoreCodes(state);
-  const preamble = aliasPreamble(state, name);
-  const source = [preamble, ensureSemicolon(input), name].filter(Boolean).join("\n");
-  let lib;
-  try {
-    lib = hydrateObject(compileLibrary(source, { source: "<repl>", libraries: [stateLibrary(state)] }));
-  } catch (error) {
-    throw remapError(error, preambleLineCount(preamble));
-  }
-  const hash = lib.relAlias?.[name];
-  if (!hash || !lib.rels?.[hash]) throw new Error(`Relation definition did not produce an alias for '${name}'`);
-  state.codes = codes.dump();
-  state.rels[hash] = lib.rels[hash];
-  state.relAliases[name] = hash;
-  state.lastMain = name;
-  mergeMeta(state, lib.meta);
-  rememberOrigin(state, hash, name, "rel");
-  return [`${name} = ${hash}`];
-}
-
 async function executeExpressionWithWasm(annotated, state, lineOffset = 0) {
   const mainRel = annotated.rels.__main__;
   if (!mainRel) return { result: undefined, wasmCompileMs: 0, executeMs: 0 };
@@ -1171,13 +1151,10 @@ async function loadCodec(input, state) {
   const [subcommand, ...rest] = trimmed.split(/\s+/);
   switch (subcommand) {
     case "load": {
-      const filePath = rest.join(" ");
-      if (!filePath) throw new Error(":codec load requires a file path or codec name");
-      const autoLoaded = ensureCodecDependencies(state, filePath);
+      const filePath = rest.join(" ").trim();
+      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 === UNIVERSAL_CODE ? "all types" : codeHash}${autoLoaded ? ` (auto-loaded ${autoLoaded})` : ""}`
-      );
+      return registered.map(({ name }) => `loaded codec ${name}`);
     }
     case "unload": {
       const codecName = rest.join(" ").trim();
@@ -1186,64 +1163,56 @@ async function loadCodec(input, state) {
       if (removed === 0) throw new Error(`Codec '${codecName}' is not loaded`);
       return [`unloaded codec ${codecName}`];
     }
-    case "define": {
-      const match = rest.join(" ").match(/^([a-zA-Z0-9_+-]+)\s+(\S+)\s+([\s\S]+)$/);
-      if (!match) {
-        throw new Error(":codec define requires: name type { parse: ..., print: ... }");
-      }
-      const [, name, rawType, bodyStr] = match;
-      const fn = new Function("Value", "isProduct", "isVariant", "state", `return (${bodyStr});`);
-      const obj = fn(Value, isProduct, isVariant, state);
-      const codeHash = rawType === "*" ? UNIVERSAL_CODE : resolveInputTypeHash(state, rawType);
-      const codec = normalizeCodecModule({
-        name,
-        codes: [codeHash],
-        universal: codeHash === UNIVERSAL_CODE,
-        parse: obj.parse,
-        print: obj.print
-      }, name);
-      const registered = registerCodec(state, codec, "<inline>");
-      return registered.map(({ name, codeHash }) =>
-        `defined codec ${name} for ${codeHash === UNIVERSAL_CODE ? "all types" : codeHash}`
-      );
-    }
+    case "define":
+      throw new Error(":codec define has been removed; all codecs are loaded from files via :codec load <file.mjs>");
     case "list":
       if (rest.length > 0) throw new Error(":codec list does not accept arguments");
       return [listCodecs(state)];
     default: {
-      const autoLoaded = ensureCodecDependencies(state, trimmed);
       const registered = await loadCodecModule(state, expandHome(trimmed));
-      return registered.map(({ name, codeHash }) =>
-        `loaded codec ${name} for ${codeHash === UNIVERSAL_CODE ? "all types" : codeHash}${autoLoaded ? ` (auto-loaded ${autoLoaded})` : ""}`
-      );
+      return registered.map(({ name }) => `loaded codec ${name}`);
     }
   }
 }
 
 async function requestCodecInput(input, state) {
-  const trimmed = input.trim();
+  let trimmed = input.trim();
   if (!trimmed) {
-    throw new Error(":input requires a type and optional codec name");
+    const loaded = Object.keys(state.codecs || {});
+    const loadedStr = loaded.length > 0 ? `Loaded: ${loaded.join(", ")}` : "None loaded";
+    return [
+      "Usage: :input <codec.mjs> [text]",
+      `Loaded codecs: ${loadedStr}`
+    ];
   }
 
-  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;
-    }
+  if (trimmed.startsWith("$")) {
+    trimmed = trimmed.slice(1).trim();
   }
 
-  const codec = resolveCodec(state, codeHash, codecName, "parse");
-  state.pendingInput = { codeHash, codecName, promptName: codec.name };
-  return [`input ${codeHash}${codecName ? ` using ${codecName}` : ""}: enter value text`];
+  const match = trimmed.match(/^([a-zA-Z0-9_?!+.-]+)(?:\s+([\s\S]*))?$/);
+  if (!match) {
+    throw new Error("Invalid :input syntax. Usage: :input <codec.mjs> [text]");
+  }
+
+  const codecName = match[1];
+  const inlineText = match[2];
+
+  const codec = resolveCodec(state, codecName, "parse");
+
+  if (inlineText !== undefined) {
+    const parsed = await codec.parse(inlineText, { state, codecName: codec.name });
+    const value = ensureEnveloped(parsed, codec);
+    state.value = value;
+    state.lastResult = value;
+    return [printValue(value, state)];
+  }
+
+  state.pendingInput = {
+    codecName: codec.name,
+    promptName: codec.name
+  };
+  return [];
 }
 
 async function consumeCodecInput(input, state) {
@@ -1252,14 +1221,12 @@ async function consumeCodecInput(input, state) {
   state.pendingInput = null;
 
   restoreCodes(state);
-  const codec = resolveCodec(state, pending.codeHash, pending.codecName, "parse");
-  const pattern = codeHashToPattern(pending.codeHash, codes.find);
+  const codec = resolveCodec(state, pending.codecName, "parse");
   const parsed = await codec.parse(input, {
-    codeHash: pending.codeHash,
-    pattern,
-    state
+    state,
+    codecName: codec.name
   });
-  const value = valueForCode(parsed, pending.codeHash, codes.find);
+  const value = ensureEnveloped(parsed, codec);
   state.value = value;
   state.lastResult = value;
   return [printValue(value, state)];
@@ -1298,34 +1265,16 @@ async function evaluateCommand(line, state) {
       exit(0);
     case "help":
       return [helpText()];
-    case "timing": {
-      const trimmed = arg.trim().toLowerCase();
-      if (trimmed === "on" || trimmed === "true" || trimmed === "1") {
-        state.showTiming = true;
-      } else if (trimmed === "off" || trimmed === "false" || trimmed === "0") {
-        state.showTiming = false;
-      } else if (!trimmed) {
-        state.showTiming = !state.showTiming;
-      } else {
-        throw new Error(":timing accepts 'on', 'off', or no arguments to toggle");
-      }
-      return [`timing reporting ${state.showTiming ? "enabled" : "disabled"}`];
-    }
+    case "timing":
+      throw new Error(":timing has been removed; timing is now always enabled");
     case "time": {
       if (!arg) throw new Error(":time requires an expression");
-      const wasTiming = state.showTiming;
-      state.showTiming = true;
-      try {
-        return await evaluateInput(arg, state);
-      } finally {
-        state.showTiming = wasTiming;
-      }
+      return evaluateInput(arg, state);
     }
     case "type": {
-      if (!arg) throw new Error(":type requires a name or definition");
+      if (!arg) throw new Error(":type requires a type name");
       if (arg.includes("=")) {
-        const definition = arg.trim().startsWith("$") ? arg : `$ ${arg}`;
-        return defineType(definition, state);
+        throw new Error("Type definitions use syntax: $ name = typeExpr; Use :type <name> to show a type definition");
       }
       return evaluateCommand(`:C ${arg}`, state);
     }
@@ -1333,8 +1282,7 @@ async function evaluateCommand(line, state) {
       return evaluateCommand(`:C ${arg}`, state);
     case "rel":
     case "def":
-      if (!arg) throw new Error(`:${command} requires a relation definition`);
-      return defineRelation(arg, state);
+      throw new Error("Relation definitions use syntax: name = relExpr;");
     case "run":
     case "eval":
       return runExpression(arg, state);
@@ -1342,11 +1290,6 @@ async function evaluateCommand(line, state) {
       return [listAliases(state.typeAliases)];
     case "rels":
       return [listAliases(state.relAliases)];
-    case "val":
-      return [
-        printValue(state.value, state),
-        JSON.stringify(state.value, null, 2)
-      ];
     case "codec":
     case "codecs":
       return loadCodec(arg, state);
@@ -1403,26 +1346,21 @@ async function evaluateCommand(line, state) {
 
 function helpText() {
   return [
-    ":type name = <...>   define a type",
-    ":rel name = expr     define a relation",
     ":run expr            run an expression on the current value",
     ":time expr           run an expression and report compilation/execution time",
-    ":timing [on|off]     toggle timing reporting after every evaluation",
     ":t name              show relation type",
     ":d name              show relation definition",
     ":type name           show type definition",
     ":codes               list type aliases",
     ":rels                list relation aliases",
-    ":codec load file     load a REPL codec module (or built-in: int, utf8, json, ieee)",
-    ":codec define n t b  define a custom codec: name type { parse: ..., print: ... }",
+    ":codec load file     load a codec module from file (e.g. :codec load codecs/int.mjs)",
     ":codec unload name   unload a registered codec",
     ":codec list          list loaded codecs (or simply :codecs)",
-    ":input type [codec]  read next line as codec input",
+    ":input <codec.mjs> [text]  parse input using specified codec",
     ":load [--no-alias] file",
     "                     load .k source or .klib",
     ":klib file           export state as a library",
     ":ko file expr        export executable .ko using expr as main",
-    ":val                 print current value",
     ":reset               clear state",
     ":help                show this help",
     "",
@@ -1568,14 +1506,18 @@ export {
   registerCodec,
   unregisterCodec,
   resolveCodec,
+  resolveInputTypeHash,
+  resolveInputPattern,
+  valueForPattern,
   codeHashToPattern,
-  BUILTIN_CODECS,
   printValue,
   promptForState,
   propertyListToFilter,
   savedLibrary,
   loadSourceOrKlib,
-  ensureCodecDependencies,
   valueToK,
-  formatDuration
+  formatDuration,
+  codecNames,
+  ensureEnveloped,
+  patternFromFilter
 };