@fraczak/k 6.10.4 → 6.10.6

package/core.k

@@ -4,15 +4,12 @@
 --   1. $bits — the canonical binary number / bit-path type
 --   2. $string — unicode strings (used for labels)
 --   3. $pattern — the type of pattern graphs
---   4. Basic $bits arithmetic: succ, plus, times
 
 ---------------------------------------------------------------
 -- §1. Bits
 ---------------------------------------------------------------
 
 $ bit = < {} 0, {} 1 >;
-b0 = {}|0 $bit;
-b1 = {}|1 $bit;
 
 $ bits = < {} _, bits 0, bits 1 >;
 
@@ -21,78 +18,8 @@ _ = {}|_;
 0 = _ |0;
 1 = _ |1;
 
-inv = {() x, _ r} _inv;
-_inv = ${bits x, bits r} < {.x /0 x, .r |0 r} _inv, {.x /1 x, .r |1 r} _inv, .r >;
-
-concat = ${bits x, bits y} {.x inv x, .y y} concat_;
-concat_ = ${bits x, bits y}
-  <
-    {.x /0 x, .y |0 y} concat_,
-    {.x /1 x, .y |1 y} concat_,
-    .y
-  >;
-
----------------------------------------------------------------
--- §2. Bits arithmetic
----------------------------------------------------------------
-
--- successor (increment by 1)
-succ = {inv x, _ y} _inc;
-
-_inc = ?{X x, X y} 
-<
-    {.x </0,/_|_> x, .y |1 y} concat_,
-    {.x /1 x, .y |0 y} _inc
-> ?X;
-
--- constants
-2 = 1 succ;
-3 = 2 succ;
-4 = 3 succ;
-5 = 4 succ;
-6 = 5 succ;
-7 = 6 succ;
-8 = 7 succ;
-9 = 8 succ;
-10 = 9 succ;
-
--- 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}
-  <
-    {.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
-  >;
-
--- multiplication on $bits (unsigned, shift-and-add)
-times = ${bits x, bits y} {0 result, .x inv _x, .y y} _times;
-_times = ${bits result, bits _x, bits y}
-  <
-    { .y /_ if, .result then } .then,
-    {
-      .result |0 result,
-      ._x _x,
-      .y /0 y
-    } _times,
-    {
-      {._x x, .result |0 y, b0 c} _plus result,
-      ._x _x,
-      .y /1 y
-    } _times
-  >;
-
 ---------------------------------------------------------------
--- §3. Unicode and String
+-- §2. Unicode and String
 ---------------------------------------------------------------
 
 -- 8-bit octet used as a building block for UTF-8 payload pieces.
@@ -108,8 +35,9 @@ $ ascii = { bit 6, bit 5, bit 4, bit 3, bit 2, bit 1, bit 0 };
 -- Plane 0 is the Basic Multilingual Plane (BMP): U+0000..U+FFFF.
 $ u0080_07FF = { bit 10, bit 9, bit 8, bit 7, bit 6, bit 5, bit 4, bit 3, bit 2, bit 1, bit 0 };
 
--- High-byte classes for common BMP ranges, excluding surrogate/private-use partitions.
--- BMP (Basic Multilingual Plane) is Plane 0: the first 65,536 code points.
+-- High-byte classes for common BMP ranges, excluding surrogate and
+-- private-use partitions.
+-- BMP (Basic Multilingual Plane) is Plane 0: first 65,536 code points.
 $ bmp_hi_common = <
   { bit 2, bit 1, bit 0 } h08_0F,
   { bit 6, bit 5, bit 4, bit 3, bit 2, bit 1, bit 0 } h10_7F,
@@ -158,12 +86,12 @@ $ unicode = <
 $ string = < {} nil, { unicode car, string cdr } cons >;
 
 ---------------------------------------------------------------
--- §4. Pattern
+-- §3. Pattern
 ---------------------------------------------------------------
 
 -- Edge: a labeled edge in a pattern graph.
 -- 'label' is the field name or tag name.
--- 'target' is the index (as $bits) of the target node in the pattern list.
+-- 'target' is index (as $bits) of the target node in the pattern list.
 
 $ edge = { string label, bits target };
 

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.6",
     "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);
@@ -131,7 +131,6 @@ for (const filename of verifiedCodecs) {
     });
     const bundledContent = buildRes.outputFiles[0].text;
     vfsFiles[filename] = bundledContent;
-    vfsFiles[`codecs/${filename}`] = bundledContent;
   }
 }
 
@@ -1663,14 +1662,15 @@ 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>
               <option value="expr:()">()</option>
               <option value="expr:$ bool = &lt; {} true, {} false &gt;; not = $ bool &lt; / true | false, {} | true &gt; $ bool; {} | true not">not (boolean relation with fallback)</option>
-              <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>
@@ -1693,8 +1693,8 @@ const htmlContent = `<!DOCTYPE html>
         </div>
 
         <!-- File Upload -->
-        <label class="btn btn-secondary btn-file" title="Upload local .k or .klib file into VFS">
-          <input type="file" id="file-upload" accept=".k,.klib,.wat,.ko" style="display:none;">
+        <label class="btn btn-secondary btn-file" title="Upload local file into VFS">
+          <input type="file" id="file-upload" accept=".k,.klib,.wat,.ko,.mjs,.js,.json" style="display:none;">
           <span>📁 Upload</span>
         </label>
 

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

@@ -144,6 +144,7 @@ if (chromiumBin) {
       "ieee.mjs",
       "int.mjs",
       "json.mjs",
+      "karatsuba-mult.k",
       "poly.k",
       "unit.mjs",
       "utf8.mjs"
@@ -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");
@@ -618,7 +635,81 @@ if (chromiumBin) {
     assert.strictEqual(engineCheck.jsEngine, "js");
     assert.strictEqual(engineCheck.badgeJsText, "js-in-process");
     assert.strictEqual(engineCheck.wasmEngine, "wasm");
-    assert.strictEqual(engineCheck.badgeWasmText, "wasm-in-process");
+    // 7. Test uploading a file (adds to VFS without auto-loading)
+    const uploadCheck = await evaluateAsync(`(async () => {
+      const codecCode = \`export default {
+        name: "custom.mjs",
+        target: "(...)",
+        format: "custom",
+        parse: (raw) => raw,
+        print: (v) => "CUSTOM_VAL"
+      };\`;
+      const file = new File(
+        [codecCode],
+        "custom.mjs",
+        { type: "text/javascript" }
+      );
+      await window.kRepl.handleFileUpload(file);
+
+      const vfsContent = window.kRepl.getVfsFile("custom.mjs");
+      const inVfsList = window.kRepl.getAllVfsFiles().includes("custom.mjs");
+
+      // Verify system message showed upload confirmation
+      const systemMessages = Array.from(
+        document.querySelectorAll(".system-msg")
+      ).map(el => el.textContent);
+      const hasUploadedMsg = systemMessages.some(
+        m => m.includes("Uploaded custom.mjs into VFS")
+      );
+
+      // Verify it was NOT auto-loaded (:codecs does not list it)
+      await window.kRepl.executeCommand(":codecs");
+      const linesBefore = Array.from(
+        document.querySelectorAll(".entry-line")
+      ).map(el => el.textContent);
+      const codecsBefore = linesBefore[linesBefore.length - 1];
+
+      // Explicitly load it to prove it can be loaded as a codec
+      await window.kRepl.executeCommand(":codec load custom.mjs");
+      const linesAfter = Array.from(
+        document.querySelectorAll(".entry-line")
+      ).map(el => el.textContent);
+      const codecsAfter = linesAfter[linesAfter.length - 1];
+
+      return {
+        hasVfsContent: typeof vfsContent === "string" &&
+          vfsContent.includes("custom.mjs"),
+        inVfsList,
+        hasUploadedMsg,
+        codecsBefore,
+        codecsAfter
+      };
+    })()`);
+    assert.strictEqual(
+      uploadCheck.hasVfsContent,
+      true,
+      "Uploaded file must be present in VFS"
+    );
+    assert.strictEqual(
+      uploadCheck.inVfsList,
+      true,
+      "Uploaded file must be in getAllVfsFiles()"
+    );
+    assert.strictEqual(
+      uploadCheck.hasUploadedMsg,
+      true,
+      "Upload confirmation message must be displayed"
+    );
+    assert.strictEqual(
+      uploadCheck.codecsBefore.includes("custom.mjs"),
+      false,
+      "Upload must NOT auto-load the file"
+    );
+    assert.strictEqual(
+      uploadCheck.codecsAfter.includes("custom.mjs"),
+      true,
+      "Explicit :codec load of uploaded file must succeed"
+    );
 
     ws.close();
     console.log("   Browser execution verified successfully!");