@fraczak/k 6.1.3 → 6.2.0

package/k-vscode/test/background-ranges.test.js

@@ -0,0 +1,50 @@
+const assert = require("assert");
+const Module = require("module");
+
+const originalLoad = Module._load;
+Module._load = function load(request, parent, isMain) {
+  if (request === "vscode") return {};
+  return originalLoad.call(this, request, parent, isMain);
+};
+
+const { collectBackgroundRanges } = require("../extension");
+
+function slices(text, ranges) {
+  return ranges.map(({ start, end }) => text.slice(start, end));
+}
+
+const source = [
+  "$ pair = { leaf left, leaf right };",
+  "pick = $pair ?{<$leaf some, ...>=X branch, ...} .branch;",
+  "-- ?<ignored tag>",
+  "/* $ignored */",
+  "$pair pick"
+].join("\n");
+
+const ranges = collectBackgroundRanges(source);
+const type = slices(source, ranges.type);
+const filter = slices(source, ranges.filter);
+
+assert.deepStrictEqual(type, [
+  "$ pair = { leaf left, leaf right };",
+  "$pair",
+  "$leaf",
+  "$pair"
+]);
+assert.deepStrictEqual(filter, ["?{<$leaf some, ...>=X branch, ...}"]);
+
+const nested = "add = ?{ $nat x, ... } = X <{.x pred x, .y succ y} ? X add, .y> ;";
+const nestedRanges = collectBackgroundRanges(nested);
+
+assert.deepStrictEqual(slices(nested, nestedRanges.filter), [
+  "?{ $nat x, ... } = X",
+  "? X"
+]);
+assert.deepStrictEqual(slices(nested, nestedRanges.type), ["$nat"]);
+assert.deepStrictEqual(nestedRanges.filter, [
+  { start: 6, end: 26 },
+  { start: 51, end: 54 }
+]);
+assert.deepStrictEqual(nestedRanges.type, [{ start: 9, end: 13 }]);
+
+console.log("background range scanner tests passed");

package/k-vscode/themes/k-contrast-color-theme.json

@@ -0,0 +1,104 @@
+{
+  "$schema": "vscode://schemas/color-theme",
+  "name": "k Contrast",
+  "type": "dark",
+  "colors": {
+    "editor.background": "#161B22",
+    "editor.foreground": "#C9D1D9",
+    "editorLineNumber.foreground": "#6E7681",
+    "editorLineNumber.activeForeground": "#C9D1D9",
+    "editor.selectionBackground": "#264F78",
+    "editor.inactiveSelectionBackground": "#264F7855"
+  },
+  "tokenColors": [
+    {
+      "scope": [
+        "comment.block.k",
+        "comment.line.k"
+      ],
+      "settings": {
+        "foreground": "#8B949E",
+        "fontStyle": "italic"
+      }
+    },
+    {
+      "scope": "entity.name.type.k",
+      "settings": {
+        "foreground": "#FF7B72",
+        "fontStyle": "bold"
+      }
+    },
+    {
+      "scope": "support.type.k",
+      "settings": {
+        "foreground": "#FFA657"
+      }
+    },
+    {
+      "scope": "support.function.identifier.k",
+      "settings": {
+        "foreground": "#79C0FF"
+      }
+    },
+    {
+      "scope": "support.type.canonical.k",
+      "settings": {
+        "foreground": "#F778BA"
+      }
+    },
+    {
+      "scope": "support.function.canonical.k",
+      "settings": {
+        "foreground": "#FF967D"
+      }
+    },
+    {
+      "scope": "entity.name.label.k",
+      "settings": {
+        "foreground": "#7EE787"
+      }
+    },
+    {
+      "scope": "entity.name.tag.k",
+      "settings": {
+        "foreground": "#F2CC60"
+      }
+    },
+    {
+      "scope": "variable.other.pattern.k",
+      "settings": {
+        "foreground": "#56D4DD"
+      }
+    },
+    {
+      "scope": [
+        "keyword.operator.assignment.k",
+        "keyword.operator.binding.k",
+        "keyword.operator.filter.k",
+        "keyword.operator.projection.product.k",
+        "keyword.operator.projection.union.k",
+        "keyword.operator.type.k",
+        "keyword.operator.variant.k"
+      ],
+      "settings": {
+        "foreground": "#FFDF5D"
+      }
+    },
+    {
+      "scope": "punctuation.definition.canonical.k",
+      "settings": {
+        "foreground": "#B392F0"
+      }
+    },
+    {
+      "scope": [
+        "constant.language.any.k",
+        "string.quoted.double.k",
+        "string.quoted.single.k"
+      ],
+      "settings": {
+        "foreground": "#A5D6FF"
+      }
+    }
+  ]
+}

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@fraczak/k",
-    "version": "6.1.3",
+    "version": "6.2.0",
     "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; node test-ieee-arithmetic.mjs; ./tests.sh",
+        "test": "node scripts/run-tests.mjs",
         "perf:idempotency": "node scripts/benchmark-idempotency.mjs",
         "deps:graph": "node scripts/generate-dependency-graph.mjs"
     },

package/repl.mjs

@@ -213,6 +213,40 @@ function mergeLibrary(state, lib, source = "<load>", options = {}) {
   restoreCodes(state);
 }
 
+function reachableRelations(rels, roots) {
+  const reachable = new Set();
+  const queue = [...roots];
+
+  function walkExp(exp) {
+    if (!exp) return;
+    switch (exp.op) {
+      case "ref":
+        if (exp.ref in rels && !reachable.has(exp.ref)) queue.push(exp.ref);
+        break;
+      case "comp":
+        exp.comp.forEach(walkExp);
+        break;
+      case "union":
+        exp.union.forEach(walkExp);
+        break;
+      case "product":
+        exp.product.forEach(({ exp: child }) => walkExp(child));
+        break;
+    }
+  }
+
+  while (queue.length > 0) {
+    const hash = queue.shift();
+    if (reachable.has(hash) || !(hash in rels)) continue;
+    reachable.add(hash);
+    walkExp(rels[hash].def);
+  }
+
+  return Object.fromEntries(
+    Object.entries(rels).filter(([hash]) => reachable.has(hash))
+  );
+}
+
 function savedLibrary(state) {
   const meta = cloneJSON(state.meta);
   const now = new Date().toISOString();
@@ -226,13 +260,20 @@ function savedLibrary(state) {
     if (meta[hash].type == null) meta[hash].type = "rel";
     meta[hash].origins.push({ source: "<repl>", name, compiledAt: now });
   }
+  const rels = reachableRelations(state.rels, Object.values(state.relAliases));
+  const storedHashes = new Set([
+    ...Object.keys(state.codes),
+    ...Object.keys(rels)
+  ]);
   return {
     format: "k-object",
     codes: state.codes,
-    rels: state.rels,
+    rels,
     relAlias: state.relAliases,
     compileStats: { sccs: [], sccCount: 0 },
-    meta,
+    meta: Object.fromEntries(
+      Object.entries(meta).filter(([hash]) => storedHashes.has(hash))
+    ),
     main: null
   };
 }

package/scripts/run-tests.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const node = process.execPath;
+const derivationTests = fs.readdirSync(path.join(root, "tests/code-derivation"))
+  .filter((name) => name.endsWith(".mjs"))
+  .sort()
+  .map((name) => [`tests/code-derivation/${name}`, node, [`tests/code-derivation/${name}`]]);
+
+const tests = [
+  ["tests/test.mjs", node, ["tests/test.mjs"]],
+  ...derivationTests,
+  ["tests/test-fingerprint.mjs", node, ["tests/test-fingerprint.mjs"]],
+  ["tests/test-hash-fuzz.mjs", node, ["tests/test-hash-fuzz.mjs"]],
+  ["tests/test-hash-normalization.mjs", node, ["tests/test-hash-normalization.mjs"]],
+  ["tests/test-k-object.mjs", node, ["tests/test-k-object.mjs"]],
+  ["tests/test-repl.mjs", node, ["tests/test-repl.mjs"]],
+  ["tests/test-ieee-arithmetic.mjs", node, ["tests/test-ieee-arithmetic.mjs"]],
+  ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]
+];
+
+function formatDuration(milliseconds) {
+  if (milliseconds < 1000) return `${milliseconds.toFixed(0)} ms`;
+  return `${(milliseconds / 1000).toFixed(2)} s`;
+}
+
+const suiteStarted = performance.now();
+for (const [name, command, args] of tests) {
+  console.log(`\n==> ${name}`);
+  const started = performance.now();
+  const result = spawnSync(command, args, {
+    cwd: root,
+    stdio: "inherit"
+  });
+  const duration = formatDuration(performance.now() - started);
+
+  if (result.error) {
+    console.error(`<== ${name} FAILED (${duration})`);
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  if (result.status !== 0) {
+    console.error(`<== ${name} FAILED (${duration})`);
+    process.exit(result.status ?? 1);
+  }
+  console.log(`<== ${name} passed (${duration})`);
+}
+
+console.log(`\nAll tests passed (${formatDuration(performance.now() - suiteStarted)})`);

package/{Code-derivation-tests → tests/code-derivation}/codec-witness-pattern.mjs

@@ -1,7 +1,7 @@
 import assert from 'assert';
-import { parseValue } from '../valueIO.mjs';
-import { encodeToWire, decodeWire } from '../codecs/runtime/prefix-codec.mjs';
-import { Product, Variant } from '../Value.mjs';
+import { parseValue } from '../../valueIO.mjs';
+import { encodeToWire, decodeWire } from '../../codecs/runtime/prefix-codec.mjs';
+import { Product, Variant } from '../../Value.mjs';
 
 const value = parseValue('{a:{b:x,c:{}}}');
 const repeatedClosedValue = parseValue('{a:{m:{},n:{}},b:{m:{},n:{}}}');

package/{Code-derivation-tests → tests/code-derivation}/convergence-strategy.mjs

@@ -1,5 +1,5 @@
 import assert from "assert";
-import { annotate } from "../index.mjs";
+import { annotate } from "../../index.mjs";
 
 const script = `
   f = .x;

package/{Code-derivation-tests → tests/code-derivation}/dot.mjs

@@ -1,5 +1,5 @@
 import { t, in_out } from './index.mjs';
-import { hash } from '../hash.mjs';
+import { hash } from '../../hash.mjs';
 import assert from 'assert';
 
 t(`

package/{Code-derivation-tests → tests/code-derivation}/filter-syntax.mjs

@@ -1,5 +1,5 @@
 import assert from 'assert';
-import { annotate } from '../index.mjs';
+import { annotate } from '../../index.mjs';
 
 function succeeds(script) {
   assert.doesNotThrow(() => annotate(script));

package/{Code-derivation-tests → tests/code-derivation}/index.mjs

@@ -1,4 +1,4 @@
-import { annotate } from "../index.mjs";
+import { annotate } from "../../index.mjs";
 
 function in_out(annotated) {
   const [input,output] = annotated.rels.__main__.def.patterns.map( (pat) => 

package/{Code-derivation-tests → tests/code-derivation}/pattern-envelope.mjs

@@ -1,9 +1,9 @@
 import assert from "node:assert/strict";
-import k from "../index.mjs";
-import { Product, Variant, mergePatterns, withPattern } from "../Value.mjs";
-import { decodeWire, encodeToWire } from "../codecs/runtime/prefix-codec.mjs";
-import run from "../run.mjs";
-import codes from "../codes.mjs";
+import k from "../../index.mjs";
+import { Product, Variant, mergePatterns, withPattern } from "../../Value.mjs";
+import { decodeWire, encodeToWire } from "../../codecs/runtime/prefix-codec.mjs";
+import run from "../../run.mjs";
+import codes from "../../codes.mjs";
 
 const INT_PATTERN = [
   ["closed-union", [["+", 1], ["-", 1]]],

package/{Code-derivation-tests → tests/code-derivation}/product.mjs

@@ -1,6 +1,6 @@
 import { t, in_out } from './index.mjs';
 import assert from 'assert';
-import hash from "../hash.mjs";
+import hash from "../../hash.mjs";
 
 const unitCode = hash('$C0={};');
 

package/{tests.sh → tests/integration.sh}

@@ -1,7 +1,9 @@
+#!/usr/bin/env bash
+set -euo pipefail
 
 # This script is used to run the k.mjs interpreter with various test cases.
 
-echo "Running './tests.sh' ..."
+echo "Running './tests/integration.sh' ..."
 
 echo '["zebara", "ela", "kupa", ala, owca]' | node ./codecs/k-parse.mjs | ./k.mjs '{.1 0,.3 1}' | node ./codecs/k-print.mjs
 echo 

package/{test-fingerprint.mjs → tests/test-fingerprint.mjs}

@@ -1,6 +1,6 @@
-import k from './index.mjs';
-import { encodeCodeToString, find } from './codes.mjs';
-import hash from './hash.mjs';
+import k from '../index.mjs';
+import { encodeCodeToString, find } from '../codes.mjs';
+import hash from '../hash.mjs';
 [
     `
     $bits = < bits 0,  bits 1, {} _ >;

package/{test-hash-fuzz.mjs → tests/test-hash-fuzz.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import assert from "node:assert/strict";
-import { annotate } from "./index.mjs";
+import { annotate } from "../index.mjs";
 
 function mulberry32(seed) {
   let t = seed >>> 0;

package/{test-hash-normalization.mjs → tests/test-hash-normalization.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 import assert from "node:assert/strict";
-import { annotate } from "./index.mjs";
-import { hash } from "./hash.mjs";
+import { annotate } from "../index.mjs";
+import { hash } from "../hash.mjs";
 
 const nameRegex = /^[a-zA-Z0-9_+][a-zA-Z0-9_?!+]*$/;
 

package/{test-ieee-arithmetic.mjs → tests/test-ieee-arithmetic.mjs}

@@ -1,10 +1,10 @@
 import assert from "node:assert/strict";
 
-import { createState, evaluateInput } from "./repl.mjs";
-import { Product } 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 { createState, evaluateInput } from "../repl.mjs";
+import { Product } 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";
 
 const state = createState();
 await evaluateInput(":load Examples/ieee.k", state);
@@ -44,7 +44,7 @@ function assertFloatResult(value, expected, label) {
   assert.equal(printFloat64(value), expected, label);
 }
 
-async function assertOperation({ op, x, y, result, flags = null }) {
+async function assertOperation({ op, x, y, result, flags = null, projection = false }) {
   const bundle = await runOperation(op, x, y);
   assert.ok(bundle instanceof Product, `${op} should return a result bundle`);
   assert.deepEqual(Object.keys(bundle.product).sort(), ["flags", "result"]);
@@ -53,37 +53,24 @@ async function assertOperation({ op, x, y, result, flags = null }) {
     assert.equal(bundle.product.flags.tag, flags, `${op}(${x}, ${y}).flags`);
   }
 
-  const projected = await runProjectedResult(op, x, y);
-  assertFloatResult(projected, result, `${op}(${x}, ${y}).result projection`);
+  if (projection) {
+    const projected = await runProjectedResult(op, x, y);
+    assertFloatResult(projected, result, `${op}(${x}, ${y}).result projection`);
+  }
 }
 
 const cases = [
-  // Addition: same sign, cancellation, exact fractional add, and specials.
-  { op: "add", x: "1", y: "1", result: "2", flags: "none" },
-  { op: "add", x: "-1", y: "1", result: "0", flags: "none" },
-  { op: "add", x: "0.5", y: "0.25", result: "0.75", flags: "none" },
+  // Keep this as a fast smoke matrix. Examples/ieee.k has detailed relation-level coverage.
+  { op: "add", x: "0.5", y: "0.25", result: "0.75", flags: "none", projection: true },
   { op: "add", x: "Infinity", y: "-Infinity", result: "NaN", flags: "invalid" },
-  { op: "add", x: "NaN", y: "1", result: "NaN", flags: "none" },
 
-  // Subtraction: positive result, negative result, signed-zero-equivalent, and invalid infinity subtraction.
-  { op: "sub", x: "4", y: "2", result: "2", flags: "none" },
+  // Cover each finite arithmetic implementation, including sign and fractional results.
   { op: "sub", x: "2", y: "4", result: "-2", flags: "none" },
-  { op: "sub", x: "0", y: "0", result: "0", flags: "none" },
-  { op: "sub", x: "Infinity", y: "Infinity", result: "NaN", flags: "invalid" },
-
-  // Multiplication: positive, signed, zero, and invalid infinity-by-zero.
-  { op: "mul", x: "4", y: "2", result: "8", flags: "none" },
   { op: "mul", x: "-2", y: "4", result: "-8", flags: "none" },
-  { op: "mul", x: "0", y: "5", result: "0", flags: "none" },
   { op: "mul", x: "Infinity", y: "0", result: "NaN", flags: "invalid" },
-
-  // Division: normalized exact cases, fractional quotient, divide-by-zero, invalid zero-over-zero, and infinity quotient.
-  { op: "div", x: "4", y: "2", result: "2" },
-  { op: "div", x: "1", y: "1", result: "1" },
   { op: "div", x: "1", y: "2", result: "0.5" },
   { op: "div", x: "1", y: "0", result: "Infinity", flags: "div_by_zero" },
-  { op: "div", x: "0", y: "0", result: "NaN", flags: "invalid" },
-  { op: "div", x: "Infinity", y: "2", result: "Infinity", flags: "none" }
+  { op: "div", x: "0", y: "0", result: "NaN", flags: "invalid" }
 ];
 
 for (const testCase of cases) {

package/{test-k-object.mjs → tests/test-k-object.mjs}

@@ -1,11 +1,11 @@
 import assert from "node:assert";
 import fs from "node:fs";
-import k from "./index.mjs";
-import { parseValue } from "./valueIO.mjs";
-import { decodeWire, encodeToWire, CORE_PATTERN_PROPERTY_LIST } from "./codecs/runtime/prefix-codec.mjs";
-import { Product, Variant } from "./Value.mjs";
-import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
-import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
+import k from "../index.mjs";
+import { parseValue } from "../valueIO.mjs";
+import { decodeWire, encodeToWire, CORE_PATTERN_PROPERTY_LIST } from "../codecs/runtime/prefix-codec.mjs";
+import { Product, Variant } from "../Value.mjs";
+import { exportPatternGraph } from "../codecs/runtime/codec.mjs";
+import { patternToPropertyList } from "../codecs/runtime/pattern-json.mjs";
 import {
   compileObjectBuffer,
   compileLibraryBuffer,
@@ -14,7 +14,7 @@ import {
   runConvergedObject,
   decompileObjectBuffer,
   extractAliasesFromObject
-} from "./object.mjs";
+} from "../object.mjs";
 
 const value = parseValue("{a:{b:x,c:{}}}");
 const wire = encodeToWire(value, null);
@@ -96,7 +96,7 @@ const natDecompiledSource = decompileObjectBuffer(natLibraryBuffer);
 const natRoundTripSource = decompileObjectBuffer(
   compileLibraryBuffer(natDecompiledSource, { source: "Examples/nat.decompiled.k" })
 );
-const recursiveNatPattern = /\?\{<X0 succ, \.\.\.>=X0 x, <X1 succ, \.\.\.>=X1 y\} .* \?X1;/;
+const recursiveNatPattern = /\$dTww <\{\.x PgmQ x, \.y h4Wg y\} re64, \.y> \$e9WP;/;
 assert.equal(natRoundTripSource, natDecompiledSource);
 assert.match(natDecompiledSource, recursiveNatPattern);
 

package/{test-repl.mjs → tests/test-repl.mjs}

@@ -16,9 +16,9 @@ import {
   isMainEntrypoint,
   lineHasExplicitContinuation,
   lineTerminatesSnippet
-} from "./repl.mjs";
-import { decodeObject, objectToFunction } from "./object.mjs";
-import { Product } from "./Value.mjs";
+} from "../repl.mjs";
+import { decodeObject, objectToFunction } from "../object.mjs";
+import { Product } from "../Value.mjs";
 
 const state = createState();
 
@@ -90,6 +90,7 @@ await assert.rejects(
 
 const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-repl-"));
 const libPath = path.join(tmpDir, "session.klib");
+const recursiveLibPath = path.join(tmpDir, "recursive.klib");
 const koPath = path.join(tmpDir, "succ.ko");
 const sourcePath = path.join(tmpDir, "session.k");
 const codecPath = path.join(tmpDir, "bool-codec.mjs");
@@ -97,6 +98,23 @@ const symlinkPath = path.resolve(".test-k-repl-link");
 output = await evaluateInput(`:klib ${libPath}`, state);
 assert.equal(output[0], `saved ${libPath}`);
 
+const recursiveState = createState();
+await evaluateInput(":type $ nat = < {}_, nat 0, nat 1 >;", recursiveState);
+await evaluateInput(":rel 0? = $ nat < / _ {}|0, / 0 0? >;", recursiveState);
+const staleZeroHash = recursiveState.relAliases["0?"];
+await evaluateInput(":rel 0? = $ nat < / _ {}|_, / 0 0? >;", recursiveState);
+const zeroHash = recursiveState.relAliases["0?"];
+assert.notEqual(zeroHash, staleZeroHash);
+await evaluateInput("{}|_|0|0 $nat", recursiveState);
+assert.deepEqual(
+  Object.keys(recursiveState.rels).sort(),
+  [staleZeroHash, zeroHash].sort()
+);
+output = await evaluateInput(`:klib ${recursiveLibPath}`, recursiveState);
+assert.equal(output[0], `saved ${recursiveLibPath}`);
+const recursiveLibrary = JSON.parse(fs.readFileSync(recursiveLibPath, "utf8"));
+assert.deepEqual(Object.keys(recursiveLibrary.rels), [zeroHash]);
+
 completions = completeInput(`:load ${tmpDir}/ses`, state)[0];
 assert(completions.includes(`:load ${libPath}`));
 completions = completeInput(`:load --no-alias ${tmpDir}/ses`, state)[0];
@@ -176,7 +194,7 @@ assert.equal(output[0], `input ${utf8State.typeAliases.string} using utf8: enter
 output = await evaluateInput("hello", utf8State);
 assert.match(output[0], /utf8: hello/);
 
-const replPath = fileURLToPath(new URL("./repl.mjs", import.meta.url));
+const replPath = fileURLToPath(new URL("../repl.mjs", import.meta.url));
 try {
   fs.rmSync(symlinkPath, { force: true });
 } catch {}

package/{test.mjs → tests/test.mjs}

@@ -1,4 +1,4 @@
-import k from "./index.mjs";
+import k from "../index.mjs";
 
 [
   [{"unit": {}}, "()"],