@fraczak/k 5.1.2 → 6.0.0

package/test-hash-fuzz.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import { annotate } from "./index.mjs";
+
+function mulberry32(seed) {
+  let t = seed >>> 0;
+  return function () {
+    t += 0x6d2b79f5;
+    let r = Math.imul(t ^ (t >>> 15), 1 | t);
+    r ^= r + Math.imul(r ^ (r >>> 7), 61 | r);
+    return ((r ^ (r >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function randInt(rng, max) {
+  return Math.floor(rng() * max);
+}
+
+function permute(rng, arr) {
+  const out = [...arr];
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = randInt(rng, i + 1);
+    [out[i], out[j]] = [out[j], out[i]];
+  }
+  return out;
+}
+
+function renameScript(script, mapping) {
+  let out = script;
+  const temps = {};
+  let i = 0;
+  for (const from of Object.keys(mapping)) {
+    temps[from] = `__TMP_${i++}__`;
+  }
+  for (const [from, tmp] of Object.entries(temps)) {
+    const re = new RegExp(`\\b${from}\\b`, "g");
+    out = out.replace(re, tmp);
+  }
+  for (const [from, to] of Object.entries(mapping)) {
+    const re = new RegExp(`\\b${temps[from]}\\b`, "g");
+    out = out.replace(re, to);
+  }
+  return out;
+}
+
+function getRelHash(script, name) {
+  const { relAlias } = annotate(script);
+  assert.ok(relAlias[name], `missing relAlias for ${name}`);
+  return relAlias[name];
+}
+
+function generateScript(rng, count) {
+  const names = Array.from({ length: count }, (_, i) => `f${i}`);
+  const defs = names.map((name) => {
+    const roll = randInt(rng, 2);
+    const refs = names;
+    if (roll === 0) {
+      return `${name} = ();`;
+    }
+    const ref1 = refs[randInt(rng, refs.length)];
+    const ref2 = refs[randInt(rng, refs.length)];
+    return `${name} = ${ref1} ${ref2};`;
+  });
+  const main = names[0];
+  return `${defs.join("\n")}\n${main}\n`;
+}
+
+function buildRenameMap(names, rng) {
+  const perm = permute(rng, names);
+  const map = {};
+  names.forEach((name, i) => {
+    map[name] = perm[i];
+  });
+  return map;
+}
+
+const rng = mulberry32(0xdeadbeef);
+const iterations = 30;
+
+for (let i = 0; i < iterations; i++) {
+  const count = 3 + randInt(rng, 4);
+  const script = generateScript(rng, count);
+  const names = Array.from({ length: count }, (_, j) => `f${j}`);
+
+  const baseHash = getRelHash(script, "f0");
+
+  const renameMap = buildRenameMap(names, rng);
+  const renamedScript = renameScript(script, renameMap);
+  const renamedMain = renameMap.f0;
+  const renamedHash = getRelHash(renamedScript, renamedMain);
+  assert.equal(baseHash, renamedHash, "renaming should not change hash");
+
+  const lines = script.trim().split("\n");
+  const defs = lines.slice(0, -1);
+  const main = lines[lines.length - 1];
+  const reordered = `${permute(rng, defs).join("\n")}\n${main}\n`;
+  const reorderedHash = getRelHash(reordered, "f0");
+  if (baseHash !== reorderedHash) {
+    console.error("Reorder mismatch:");
+    console.error("ORIGINAL:\n" + script);
+    console.error("REORDERED:\n" + reordered);
+  }
+  assert.equal(baseHash, reorderedHash, "reordering defs should not change hash");
+}
+
+console.log("test-hash-fuzz: ok");

package/test-hash-normalization.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import { annotate } from "./index.mjs";
+import { hash } from "./hash.mjs";
+
+const nameRegex = /^[a-zA-Z0-9_+][a-zA-Z0-9_?!+]*$/;
+
+function hashBody(h) {
+  assert.ok(h.startsWith("@"), "hash must start with @");
+  return h.slice(1);
+}
+
+function getRelHash(script, name) {
+  const { relAlias } = annotate(script);
+  assert.ok(relAlias[name], `missing relAlias for ${name}`);
+  return relAlias[name];
+}
+
+// Hash format invariants
+{
+  const h = hash("abc");
+  assert.ok(nameRegex.test(hashBody(h)), "hash body must match k-name regex");
+}
+
+// Alpha-renaming of local references should not change hash
+{
+  const scriptA = `
+g = ();
+f = g;
+f
+  `;
+
+  const scriptB = `
+h = ();
+f = h;
+f
+  `;
+
+  assert.equal(
+    getRelHash(scriptA, "f"),
+    getRelHash(scriptB, "f"),
+    "alpha renaming should be stable"
+  );
+}
+
+// Direct alias vs inline definition should not change hash
+{
+  const scriptAlias = `
+g = ();
+f = g;
+f
+  `;
+
+  const scriptInline = `
+f = ();
+f
+  `;
+
+  assert.equal(
+    getRelHash(scriptAlias, "f"),
+    getRelHash(scriptInline, "f"),
+    "alias vs inline should be stable"
+  );
+}
+
+// SCC order should not change hash
+{
+  const scriptA = `
+$bit = < {} 0, {} 1 >;
+f = $bit < /0 |0 g, /1 >;
+g = $bit < /0 |0 f, /1 >;
+f
+  `;
+
+  const scriptB = `
+$bit = < {} 0, {} 1 >;
+g = $bit < /0 |0 f, /1 >;
+f = $bit < /0 |0 g, /1 >;
+f
+  `;
+
+  assert.equal(
+    getRelHash(scriptA, "f"),
+    getRelHash(scriptB, "f"),
+    "SCC order should be stable"
+  );
+}
+
+// Union ordering should be significant
+{
+  const scriptA = `
+x = < x, y >;
+y = x;
+x
+  `;
+
+  const scriptB = `
+x = < y, x >;
+y = x;
+x
+  `;
+
+  assert.notEqual(
+    getRelHash(scriptA, "x"),
+    getRelHash(scriptB, "x"),
+    "union ordering should be significant"
+  );
+}
+
+// Product ordering should be significant
+{
+  const scriptA = `
+a = ();
+b = ();
+x = { a a, b b };
+x
+  `;
+
+  const scriptB = `
+a = ();
+b = ();
+y = { b b, a a };
+y
+  `;
+
+  assert.notEqual(
+    getRelHash(scriptA, "x"),
+    getRelHash(scriptB, "y"),
+    "product ordering should be significant"
+  );
+}
+
+console.log("test-hash-normalization: ok");

package/test-k-object.mjs

@@ -0,0 +1,74 @@
+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 { compileObjectBuffer, decodeObject, objectToFunction, decompileObjectBuffer } from "./object.mjs";
+
+const value = parseValue("{a:{b:x,c:{}}}");
+const wire = encodeToWire(value, null);
+const decodedWire = decodeWire(wire);
+assert.deepEqual(decodedWire.pattern, [
+  ["open-union", [["a", 1]]],
+  ["closed-product", [["b", 2], ["c", 3]]],
+  ["open-union", [["x", 3]]],
+  ["closed-product", []]
+]);
+assert.deepEqual(decodedWire.value.toJSON(), value.toJSON());
+
+const unicodeLabelValue = new Product({
+  "é": new Variant("🙂", new Product({})),
+  "𐐷": new Product({})
+});
+const unicodeWire = encodeToWire(unicodeLabelValue, null);
+const decodedUnicode = decodeWire(unicodeWire);
+assert.deepEqual(decodedUnicode.value.toJSON(), unicodeLabelValue.toJSON());
+assert(decodedUnicode.pattern.some(([, edges]) => edges.some(([label]) => label === "é")));
+assert(decodedUnicode.pattern.some(([, edges]) => edges.some(([label]) => label === "🙂")));
+assert(decodedUnicode.pattern.some(([, edges]) => edges.some(([label]) => label === "𐐷")));
+
+const core = k.annotate(fs.readFileSync("core.k", "utf8"));
+const coreMain = core.rels.__main__;
+const corePatternId = coreMain.typePatternGraph.find(coreMain.def.patterns[0]);
+const corePattern = patternToPropertyList(exportPatternGraph(coreMain.typePatternGraph, corePatternId));
+assert.deepEqual(CORE_PATTERN_PROPERTY_LIST, corePattern);
+
+const INT_PATTERN = [
+  ["closed-union", [["+", 1], ["-", 1]]],
+  ["closed-union", [["0", 1], ["1", 1], ["_", 2]]],
+  ["closed-product", []]
+];
+
+const objectBuffer = compileObjectBuffer(`
+  $ bits = < {} _, bits 0, bits 1 >;
+  $ int = < bits +, bits - >;
+  {}|_|0|1|+ $int
+`);
+const objectFn = objectToFunction(decodeObject(objectBuffer));
+const objectResult = objectFn(new Product({}));
+assert.deepEqual(objectResult.pattern, INT_PATTERN);
+assert.deepEqual(objectResult.toJSON(), { "+": { "1": { "0": "_" } } });
+
+const decompiledSource = decompileObjectBuffer(objectBuffer);
+const decompiledResult = k.compile(decompiledSource)(new Product({}));
+assert.deepEqual(decompiledResult.pattern, INT_PATTERN);
+assert.deepEqual(decompiledResult.toJSON(), objectResult.toJSON());
+assert.match(decompiledSource, /^----- codes -----$/m);
+assert.match(decompiledSource, /^----- rels -----$/m);
+assert.match(decompiledSource, /^----- main -----$/m);
+assert.match(decompiledSource, /\$ Nws3 =/);
+assert.match(decompiledSource, /^7jfi = /m);
+assert.match(decompiledSource, /^----- main -----\n\?\(\.\.\.\) 7jfi \$Nws3$/m);
+
+assert.throws(() => k.compile("@A = (); @A"), /Parse error/);
+assert.throws(() => k.compile("$ @A = {}; $@A"), /Parse error/);
+assert.deepEqual(k.compile("7jfi = ?X0; 7jfi")(new Product({})).toJSON(), {});
+
+const sccSource = decompileObjectBuffer(compileObjectBuffer("c = {}; b = c |x; a = b |y; a"));
+assert.match(sccSource, /----- rels -----\nPQgV = .+\n\naQAD = .+\n\nN9UH = /s);
+assert.deepEqual(k.compile(sccSource)(new Product({})).toJSON(), { y: "x" });
+
+console.log("OK");

package/test-repl2.mjs

@@ -0,0 +1,95 @@
+import assert from "node:assert";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { completeInput, createState, evaluateInput } from "./repl2.mjs";
+import { decodeObject, objectToFunction } from "./object.mjs";
+import { Product } from "./Value.mjs";
+
+const state = createState();
+
+let output = await evaluateInput(":type nat = <{} zero, nat succ>", state);
+assert.match(output[0], /^\$ nat = @/);
+
+output = await evaluateInput(":rel succ = |succ", state);
+assert.match(output[0], /^succ = @/);
+
+output = await evaluateInput(":codes", state);
+assert.match(output[0], /^nat = @/m);
+
+output = await evaluateInput(":rels", state);
+assert.match(output[0], /^succ = @/m);
+
+output = await evaluateInput(":run succ", state);
+assert.equal(output[0], "{}|succ ?<{} succ, ...>");
+
+output = await evaluateInput(":t succ", state);
+assert.match(output[0], /^succ : /);
+
+output = await evaluateInput(":d succ", state);
+assert.match(output[0], /^succ = /);
+
+let completions = completeInput(":he", state)[0];
+assert.deepEqual(completions, [":help"]);
+
+const canonicalPartial = state.typeAliases.nat.slice(0, 8);
+completions = completeInput(`:run ${canonicalPartial}`, state)[0];
+assert(completions.some((line) => line.endsWith(state.typeAliases.nat)));
+
+completions = completeInput(`(${canonicalPartial}`, state)[0];
+assert(completions.includes(`(${state.typeAliases.nat}`));
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-repl2-"));
+const libPath = path.join(tmpDir, "session.klib");
+const koPath = path.join(tmpDir, "succ.ko");
+const sourcePath = path.join(tmpDir, "session.k");
+output = await evaluateInput(`:save ${libPath}`, state);
+assert.equal(output[0], `saved ${libPath}`);
+
+completions = completeInput(`:load ${tmpDir}/ses`, state)[0];
+assert(completions.includes(`:load ${libPath}`));
+
+output = await evaluateInput(`:ko ${koPath} succ`, state);
+assert.equal(output[0], `saved ${koPath} (succ)`);
+const objectFn = objectToFunction(decodeObject(fs.readFileSync(koPath)));
+const objectResult = objectFn(new Product({}, [["closed-product", []]]));
+assert.equal(objectResult.toJSON(), "succ");
+
+fs.writeFileSync(sourcePath, "$ nat = <{} zero, nat succ>;\nsucc = |succ;\n");
+const loadedSource = createState();
+output = await evaluateInput(`:load ${sourcePath}`, loadedSource);
+assert.equal(output[0], `loaded ${sourcePath}`);
+output = await evaluateInput(":codes", loadedSource);
+assert.match(output[0], /^nat = @/m);
+output = await evaluateInput(":rels", loadedSource);
+assert.match(output[0], /^succ = @/m);
+
+const reloaded = createState();
+output = await evaluateInput(`:load ${libPath}`, reloaded);
+assert.equal(output[0], `loaded ${libPath}`);
+
+output = await evaluateInput(":codes", reloaded);
+assert.match(output[0], /^nat = @/m);
+
+output = await evaluateInput(":rels", reloaded);
+assert.match(output[0], /^succ = @/m);
+
+output = await evaluateInput("succ", reloaded);
+assert.equal(output[0], "{}|succ ?<{} succ, ...>");
+
+const shorthand = createState();
+output = await evaluateInput("$ nat = <{} zero, nat succ>;", shorthand);
+assert.match(output[0], /^\$ nat = @/);
+output = await evaluateInput("succ = |succ;", shorthand);
+assert.match(output[0], /^succ = @/);
+output = await evaluateInput("succ", shorthand);
+assert.equal(output[0], "{}|succ ?<{} succ, ...>");
+
+await assert.rejects(
+  () => evaluateInput("/type", createState()),
+  /Type Error|Unknown ref: 'type'|Parse error|Parse Error/
+);
+
+fs.rmSync(tmpDir, { recursive: true, force: true });
+console.log("OK");

package/test.mjs

@@ -1,101 +1,76 @@
 import k from "./index.mjs";
 
 [
-  ["ANYTHING...", "()"],
-  ["ANYTHING...", '{"ala" name, 23 age}'],
+  [{"unit": {}}, "()"],
+  [{"name": {"ala": {}}, "age": {"twentythree": {}}}, '{.name name, .age age}'],
   [
     {
-      year: 2002,
-      age: 19,
+      "year": {"twothousandtwo": {}},
+      "age": {"nineteen": {}},
     },
-    "[.year, .age]",
-  ],
-  ["duplicate me", "[(), ()]"],
-  ["nesting", "[[[()]]]"],
-  ["nesting and accessing", "[[()]] {() nested, .0.0 val}"],
-  [
-    {
-      test: "parse integer",
-    },
-    "0000",
-  ],
-  [
-    {
-      x: 3,
-      y: 4,
-    },
-    "[.y,.x] PLUS",
+    "{.year year, .age age}",
   ],
+  [{"duplicate": {}}, "()"],
+  [{"nesting": {}}, "()"],
+  [{"test": {"parseunit": {}}}, "()"],
 ].map(function ([data, script]) {
   console.log(`k_expression = '${script}';`);
-  console.log(`k.run(k_expression,${JSON.stringify(data)});`);
+  console.log(`k.run(k_expression,data});`);
   console.log(`// RETURNS: ${JSON.stringify(k.run(script, data))}`);
   return console.log("");
 });
 
-let k_expression =
-  '{.name nom, <[.age, 18] GT "old", [.age, 12] GT "ado", "enfant"> age}';
-
-let k_fn = k.compile(k_expression);
-
-console.log(`var k_fn = k.compile('${k_expression}');`);
-
-console.log("");
-
-[
-  {
-    age: 23,
-    name: "Emily",
-  },
-  {
-    age: 16,
-    name: "Katrina",
-  },
-  {
-    age: 2,
-    name: "Mark",
-  },
-].map(function (data) {
-  console.log(`k_fn(${JSON.stringify(data)});`);
-  console.log(`// RETURNS: ${JSON.stringify(k_fn(data))}`);
-  return console.log("");
-});
-
 
-k_expression = "$ < < [ @int ] ints, [ @bool ] bools > list, @string None>";
+let k_expression = `
+  $ bool = < {} true, {} false >;
+  true = {} | true $bool;
+  false = {} | false $bool;
+  
+  list? = ?< {} nil, {X car, Y cdr} cons > = Y;
+  nil = {}|nil list?;
+  nil? = list? /nil nil;
+  car = list? /cons .car;
+  list? { 
+    < nil? true, false > nil_test,
+    < car, {}|none >  car 
+  }
+  `
+  ;
 
-k_fn = k.compile(k_expression);
+let k_fn = k.compile(k_expression);
 
 console.log(`var k_fn = k.compile('${k_expression}');`);
 
 console.log("");
 
 [
+  {"None": {}},
+  {"nil": {}},
   {
-    None: "None",
-  },
-  {
-    list: {
-      ints: [],
-    },
-  },
-  {
-    list: {
-      ints: [1, 2, 3],
-    },
-  },
-  {
-    list: {
-      bools: [true, false],
+    "cons": {
+      "car": {"unit": {}},
+      "cdr": {
+        "cons": {
+          "car": {"unit": {}},
+          "cdr": {"nil": {}}
+        }
+      }
     },
   },
   {
-    list: {
-      bools: [true, 0],
+    "cons": {
+      "car": {"on": {}},
+      "cdr": {
+        "cons": {
+          "car": {"off": {}},
+          "cdr": {"nil": {}}
+        
+        }
+      }
     },
   },
 ].map(function (data) {
   console.log(`k_fn(${JSON.stringify(data)});`);
-  console.log(`// RETURNS: ${JSON.stringify(k_fn(data))}`);
+  console.log(`// RETURNS: ${JSON.stringify(k_fn(k.fromObject(data)))}`);
   return console.log("");
 });

package/tests.sh

@@ -3,4 +3,13 @@
 
 echo "Running './tests.sh' ..."
 
-echo '[4,2,19,1]' | ./k.mjs -k Examples/rec-code.k -1
+echo '["zebara", "ela", "kupa", ala, owca]' | node ./codecs/k-parse.mjs | ./k.mjs '{.1 0,.3 1}' | node ./codecs/k-print.mjs
+echo 
+echo '-21' | node ./codecs/int.mjs --parse | node ./codecs/int.mjs --print | grep -qx -- '-21'
+echo
+node ./codecs/unit.mjs --parse | node ./codecs/unit.mjs --print | grep -qx '{}'
+echo 
+printf 'A🙂\nBé~\t' | ./codecs/utf8.mjs --parse | ./k.mjs -k Examples/byte.k |./codecs/utf8.mjs --print
+echo
+echo "1031" | ./codecs/ieee.mjs --parse | ./k.mjs -k Examples/ieee.k | ./codecs/ieee.mjs --print
+echo