@fraczak/k 6.10.4 → 6.10.5

package/core.k

@@ -58,20 +58,27 @@ _inc = ?{X x, X y}
 
 -- addition on $bits (unsigned, LSB-first with carry)
 plus = ${bits x, bits y} {.x inv x, .y inv y, b0 c} _plus;
-_plus = ${bits x, bits y, bit c}
+_plus = {.x x, .y y, .c c, _ r} _plus_;
+_plus_ = ${bits x, bits y, bit c, bits r}
   <
-    {.x /_ if, .y /_ and, <.c/0 0, 1> then} .then,
-    {.x /_ if, .c/0 and, .y then} .then,
-    {.x y, .y /_|_ x, .c c} _plus,
-    {<.c/0 0, 1> x, .y y, .x /_ b0 c} _plus,
-    {.x /0 x, .y /0 y, .c/0 b0 c} _plus |0,
-    {.x /0 x, .y /0 y, .c/1 b0 c} _plus |1,
-    {.x /0 x, .y /1 y, .c/0 b0 c} _plus |1,
-    {.x /0 x, .y /1 y, .c/1 b1 c} _plus |0,
-    {.x /1 x, .y /0 y, .c/0 b0 c} _plus |1,
-    {.x /1 x, .y /0 y, .c/1 b1 c} _plus |0,
-    {.x /1 x, .y /1 y, .c/0 b1 c} _plus |0,
-    {.x /1 x, .y /1 y, .c/1 b1 c} _plus |1
+    {.x /_ if, .y /_ and, .c/0 c, .r then} .then,
+    {.x /_ if, .y /_ and, .c/1 c, .r |1 then} .then,
+    {.x /_ if, .c/0 and, {.y x, .r y} concat_ then} .then,
+    {.y /_ if, .c/0 and, {.x x, .r y} concat_ then} .then,
+    <
+      {.x/_ _ x, .y /0 y, b0 c, .r |1 r},
+      {.x/_ _ x, .y /1 y, b1 c, .r |0 r},
+      {.y/_ _ y, .x /0 x, b0 c, .r |1 r},
+      {.y/_ _ y, .x /1 x, b1 c, .r |0 r},
+      {.x /0 x, .y /0 y, .c/0 b0 c, .r |0 r},
+      {.x /0 x, .y /0 y, .c/1 b0 c, .r |1 r},
+      {.x /0 x, .y /1 y, .c/0 b0 c, .r |1 r},
+      {.x /0 x, .y /1 y, .c/1 b1 c, .r |0 r},
+      {.x /1 x, .y /0 y, .c/0 b0 c, .r |1 r},
+      {.x /1 x, .y /0 y, .c/1 b1 c, .r |0 r},
+      {.x /1 x, .y /1 y, .c/0 b1 c, .r |0 r},
+      {.x /1 x, .y /1 y, .c/1 b1 c, .r |1 r}
+    > _plus_
   >;
 
 -- multiplication on $bits (unsigned, shift-and-add)

package/harness/suites/poly.mjs

@@ -48,7 +48,7 @@ export async function createPolySuite({ listLength = 40, cacheDir = null } = {})
     return lines.join("\n") + "\n";
   }
 
-  const neededExports = ["0", "int", "inc", "dec", "nat", "zero_int?", "nil", "cons", "car", "cdr"];
+  const neededExports = ["0", "int", "inc", "dec", "nat", "zero_int?"];
   const exportPreamble = buildExportPreamble(neededExports, [arithmeticsLib]);
   const polyLib = loadLibrary(compileLibrary(exportPreamble + polySource, {
     source: polyPath,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.10.4",
+    "version": "6.10.5",
     "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",
     "exports": {

package/repl-codecs.mjs

@@ -107,8 +107,10 @@ function registerCodec(state, rawCodec, filePath) {
 
 function unregisterCodec(state, codecName) {
   const store = codecStore(state);
-  if (!store[codecName]) return 0;
-  delete store[codecName];
+  const baseName = path.basename(codecName);
+  const key = store[codecName] ? codecName : (store[baseName] ? baseName : null);
+  if (!key) return 0;
+  delete store[key];
   return 1;
 }
 
@@ -129,7 +131,8 @@ function resolveCodec(state, codecName, capability = null) {
     throw new Error("Codec name is required");
   }
   const store = codecStore(state);
-  const codec = store[codecName];
+  const baseName = path.basename(codecName);
+  const codec = store[codecName] || store[baseName];
   if (!codec) {
     throw new Error(`Codec '${codecName}' is not loaded`);
   }

package/scripts/build-repl-html.mjs

@@ -78,8 +78,8 @@ if (fs.existsSync(coreKPath)) {
   vfsFiles["core.k"] = fs.readFileSync(coreKPath, "utf8");
 }
 
-// Add verified k-code files: arithmetics.k, ieee.k, poly.k
-const verifiedExamples = ["arithmetics.k", "ieee.k", "poly.k"];
+// Add verified k-code files: arithmetics.k, ieee.k, poly.k, karatsuba-mult.k
+const verifiedExamples = ["arithmetics.k", "ieee.k", "poly.k", "karatsuba-mult.k"];
 const examplesDir = path.join(projectRoot, "Examples");
 for (const filename of verifiedExamples) {
   const fullPath = path.join(examplesDir, filename);
@@ -130,7 +130,6 @@ for (const filename of verifiedCodecs) {
       }]
     });
     const bundledContent = buildRes.outputFiles[0].text;
-    vfsFiles[filename] = bundledContent;
     vfsFiles[`codecs/${filename}`] = bundledContent;
   }
 }
@@ -1663,6 +1662,7 @@ const htmlContent = `<!DOCTYPE html>
               <option value="arithmetics.k">arithmetics.k</option>
               <option value="ieee.k">ieee.k</option>
               <option value="poly.k">poly.k</option>
+              <option value="karatsuba-mult.k">karatsuba-mult.k</option>
             </optgroup>
             <optgroup label="Quick Expressions">
               <option value="expr:{} | ok">{} | ok</option>
@@ -1671,6 +1671,7 @@ const htmlContent = `<!DOCTYPE html>
               <option value="expr:{10 x, 5 y} plus">{10 x, 5 y} plus (bits)</option>
               <option value="expr:1 succ">1 succ</option>
               <option value="expr:{10 int x, 5 int y} plus">{10 int x, 5 int y} plus (int)</option>
+              <option value="expr:{10 int x, 5 int y} karatsuba">{10 int x, 5 int y} karatsuba</option>
               <option value="expr::types">:types (list types)</option>
               <option value="expr::rels">:rels (list relations)</option>
               <option value="expr::engine">:engine (show engine)</option>
@@ -1680,13 +1681,13 @@ const htmlContent = `<!DOCTYPE html>
             <optgroup label="Codecs &amp; Format Adapters">
               <option value="expr::codecs">:codecs</option>
               <option value="expr::input">:input (interactive dialog)</option>
-              <option value="expr::codec load int.mjs">:codec load int.mjs</option>
-              <option value="expr::codec load utf8.mjs">:codec load utf8.mjs</option>
-              <option value="expr::codec load json.mjs">:codec load json.mjs</option>
-              <option value="expr::codec load ieee.mjs">:codec load ieee.mjs</option>
-              <option value="expr::codec load unit.mjs">:codec load unit.mjs</option>
-              <option value="expr::input json.mjs {&quot;a&quot;:12,&quot;b&quot;:&quot;hello&quot;}">:input json.mjs {"a":12,"b":"hello"}</option>
-              <option value="expr::input int.mjs [0,1,2]">:input int.mjs [0,1,2]</option>
+              <option value="expr::codec load codecs/int.mjs">:codec load codecs/int.mjs</option>
+              <option value="expr::codec load codecs/utf8.mjs">:codec load codecs/utf8.mjs</option>
+              <option value="expr::codec load codecs/json.mjs">:codec load codecs/json.mjs</option>
+              <option value="expr::codec load codecs/ieee.mjs">:codec load codecs/ieee.mjs</option>
+              <option value="expr::codec load codecs/unit.mjs">:codec load codecs/unit.mjs</option>
+              <option value="expr::input codecs/json.mjs {&quot;a&quot;:12,&quot;b&quot;:&quot;hello&quot;}">:input codecs/json.mjs {"a":12,"b":"hello"}</option>
+              <option value="expr::input codecs/int.mjs [0,1,2]">:input codecs/int.mjs [0,1,2]</option>
             </optgroup>
           </select>
           <button id="btn-load-example" class="btn btn-primary">Load</button>

package/scripts/perf-poly.mjs

@@ -193,7 +193,7 @@ function buildExportPreamble(exports, libraries) {
   return lines.join("\n") + "\n";
 }
 
-const neededExports = ["0", "int", "inc", "dec", "nat", "zero_int?", "nil", "cons", "car", "cdr"];
+const neededExports = ["0", "int", "inc", "dec", "nat", "zero_int?"];
 const exportPreamble = buildExportPreamble(neededExports, [arithmeticsLib]);
 const polyLib = loadLibrary(compileLibrary(exportPreamble + polySource, {
   source: polyPath,

package/tests/test-arithmetics.mjs

@@ -100,10 +100,13 @@ try {
   assertOk(resDec, "2 int dec dec zero_int? should succeed");
 
   const divTestCases = [
+    { x: "0", yAlias: "7", yVal: 7n },
+    { x: "3", yAlias: "7", yVal: 7n },
     { x: "4", yAlias: "1", yVal: 1n },
     { x: "10", yAlias: "2", yVal: 2n },
     { x: "12", yAlias: "3", yVal: 3n },
     { x: "11", yAlias: "3", yVal: 3n },
+    { x: "12", yAlias: "12", yVal: 12n },
     { x: "100", yAlias: "7", yVal: 7n },
     { x: "-100", yAlias: "7", yVal: 7n },
     { x: "1000", yAlias: "10", yVal: 10n }
@@ -143,6 +146,99 @@ try {
     assert.equal(remOut, expectedRem, `div(${x}, ${yAlias}) remainder should match BigInt oracle`);
   }
 
+  // Regression tests for EQ
+  const dummyWire = parseIntWire("0");
+  const resEqTrue = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "EQ:EQ",
+    "--export", "int:int",
+    "--export", "2:two",
+    "{two x, two y} EQ .x int"
+  ], { input: dummyWire });
+  assertOk(resEqTrue, "{2, 2} EQ should succeed");
+
+  const resEqFalse = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "EQ:EQ",
+    "--export", "int:int",
+    "--export", "2:two",
+    "--export", "3:three",
+    "{two x, three y} EQ .x int"
+  ], { input: dummyWire });
+  assert.notEqual(resEqFalse.status, 0, "{2, 3} EQ should fail");
+
+  // Regression tests for pos?
+  const resPosTrue = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "pos?:pos?",
+    "--export", "int:int",
+    "--export", "2:two",
+    "two int pos?"
+  ], { input: dummyWire });
+  assertOk(resPosTrue, "2 int pos? should succeed");
+
+  const resPosZero = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "pos?:pos?",
+    "--export", "int:int",
+    "--export", "0:zero",
+    "zero int pos?"
+  ], { input: dummyWire });
+  assert.notEqual(resPosZero.status, 0, "0 int pos? should fail");
+
+  // Regression tests for mod, gcd, lcm
+  const resMod = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "mod:mod",
+    "--export", "int:int",
+    "--export", "10:ten",
+    "--export", "3:three",
+    "{ten x, three y} mod int"
+  ], { input: dummyWire });
+  assertOk(resMod, "10 % 3 mod");
+  assert.equal(printIntWire(resMod.stdout, "mod"), "1");
+
+  const resGcd = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "gcd:gcd",
+    "--export", "int:int",
+    "--export", "12:twelve",
+    "--export", "8:eight",
+    "{twelve x, eight y} gcd int"
+  ], { input: dummyWire });
+  assertOk(resGcd, "gcd(12, 8)");
+  assert.equal(printIntWire(resGcd.stdout, "gcd"), "4");
+
+  const resGcdZero = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "gcd:gcd",
+    "--export", "int:int",
+    "--export", "4:four",
+    "--export", "0b:zero_b",
+    "{four x, zero_b y} gcd int"
+  ], { input: dummyWire });
+  assertOk(resGcdZero, "gcd(4, 0b)");
+  assert.equal(printIntWire(resGcdZero.stdout, "gcd 0b"), "4");
+
+  const resLcm = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "lcm:lcm",
+    "--export", "int:int",
+    "--export", "4:four",
+    "--export", "6:six",
+    "{four x, six y} lcm int"
+  ], { input: dummyWire });
+  assertOk(resLcm, "lcm(4, 6)");
+  assert.equal(printIntWire(resLcm.stdout, "lcm"), "12");
+
   console.log("OK");
 } finally {
   fs.rmSync(tmpDir, { recursive: true, force: true });

package/tests/test-repl-html.mjs

@@ -139,14 +139,15 @@ if (chromiumBin) {
     const vfsList = await evaluateAsync(`window.kRepl.getAllVfsFiles().sort()`);
     const expectedFiles = [
       "arithmetics.k",
+      "codecs/ieee.mjs",
+      "codecs/int.mjs",
+      "codecs/json.mjs",
+      "codecs/unit.mjs",
+      "codecs/utf8.mjs",
       "core.k",
       "ieee.k",
-      "ieee.mjs",
-      "int.mjs",
-      "json.mjs",
-      "poly.k",
-      "unit.mjs",
-      "utf8.mjs"
+      "karatsuba-mult.k",
+      "poly.k"
     ].sort();
     assert.deepStrictEqual(vfsList, expectedFiles, `getAllVfsFiles() must match curated files list, got: ${JSON.stringify(vfsList)}`);
 
@@ -158,6 +159,22 @@ if (chromiumBin) {
     })()`);
     assert(loadOut.includes("loaded arithmetics.k"), `Expected loaded arithmetics.k, got: ${loadOut}`);
 
+    // Test :load karatsuba-mult.k
+    const loadKaratsubaOut = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand(":load karatsuba-mult.k");
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(loadKaratsubaOut.includes("loaded karatsuba-mult.k"), `Expected loaded karatsuba-mult.k, got: ${loadKaratsubaOut}`);
+
+    // Test evaluating {1 int x, 1 int y} karatsuba
+    const karatsubaVal = await evaluateAsync(`(async () => {
+      await window.kRepl.executeCommand("{1 int x, 1 int y} karatsuba");
+      const lines = Array.from(document.querySelectorAll(".entry-line")).map(el => el.textContent);
+      return lines[lines.length - 1];
+    })()`);
+    assert(karatsubaVal.includes("{}|_|1|+"), `Expected {}|_|1|+ in output, got: ${karatsubaVal}`);
+
     // Test evaluating 10
     const valOut = await evaluateAsync(`(async () => {
       await window.kRepl.executeCommand("10");