@fraczak/k 5.1.2 → 6.0.1

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,106 @@
+import assert from "node:assert";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { completeInput, createState, evaluateInput, isMainEntrypoint } 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");
+const symlinkPath = path.resolve(".test-k-repl2-link");
+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 replPath = fileURLToPath(new URL("./repl2.mjs", import.meta.url));
+try {
+  fs.rmSync(symlinkPath, { force: true });
+} catch {}
+fs.symlinkSync(replPath, symlinkPath);
+fs.chmodSync(replPath, 0o755);
+assert.equal(isMainEntrypoint(symlinkPath), true);
+
+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 });
+fs.rmSync(symlinkPath, { 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

package/type_registry/registry.mjs~

@@ -0,0 +1,105 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import codes from '../codes.mjs';
+import { parse } from './typeParser.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REGISTRY_FILE = path.join(__dirname, 'registry.json');
+const PORT = 3001;
+
+// Load existing registry if it exists
+if (fs.existsSync(REGISTRY_FILE)) {
+    console.log('Loading existing registry...');
+    try {
+        const data = fs.readFileSync(REGISTRY_FILE, 'utf8');
+        const json = JSON.parse(data);
+        codes.load(json);
+        console.log(`Loaded ${Object.keys(json).length} types.`);
+    } catch (err) {
+        console.error('Error loading registry:', err);
+    }
+} else {
+    console.log('No existing registry found. Starting fresh.');
+}
+
+const server = http.createServer((req, res) => {
+    // Helper to send JSON response
+    const sendJSON = (data, status = 200) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+
+    // Helper to send Error
+    const sendError = (message, status = 400) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: message }));
+    };
+
+    // Route: POST
+    if (req.method === 'POST') {
+        let body = '';
+        req.on('data', chunk => {
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            try {
+                // 1. Parse the input string using the Jison parser
+                // The parser expects a string of type definitions
+                console.log("Received body:", body);
+                const definitions = parse(body);
+                console.log("Parsed definitions:", JSON.stringify(definitions, null, 2));
+
+                // 2. Register the parsed codes
+                // codes.register returns the representatives map { temp_name: canonical_hash }
+                const representatives = codes.register(definitions);
+
+                // Filter out generated names (_gen_...) and canonical names (@...)
+                const filteredRepresentatives = Object.fromEntries(
+                    Object.entries(representatives).filter(([key, value]) => 
+                        !key.startsWith('_gen_') && !key.startsWith('@')
+                    )
+                );
+
+                // 3. Save to disk
+                const dump = codes.dump();
+                fs.writeFileSync(REGISTRY_FILE, JSON.stringify(dump, null, 2));
+
+                // 4. Return the mapping
+                sendJSON(filteredRepresentatives);
+
+            } catch (err) {
+                console.error(err);
+                sendError(`Registration failed: ${err.message}`);
+            }
+        });
+    }
+    // Route: GET 
+    else if (req.method === 'GET') {
+        const typeId = req.url.split('/').pop();
+        console.log("Requested type ID:", typeId);
+        if (!typeId) {
+            sendError('Missing type ID');
+            return;
+        }
+        // Decode URI component in case @ is encoded
+        const decodedId = decodeURIComponent(typeId);
+        console.log("Decoded type ID:", decodedId);
+        
+        const typeDef = codes.find(decodedId);
+        if (typeDef.code === 'undefined') {
+            sendError('Type not found', 404);
+        } else {
+            sendJSON(typeDef);
+        }
+    }
+    // 404 Not Found
+    else {
+        sendError('Not Found', 404);
+    }
+});
+
+server.listen(PORT, () => {
+    console.log(`Type Registry running at http://localhost:${PORT}/`);
+});