@fraczak/k 6.10.3 → 6.10.5

package/scripts/perf-poly.mjs

@@ -60,6 +60,73 @@ import { compileARM64ArtifactFromObject } from "../backends/arm64/src/arm64.mjs"
 import { compileWasmArtifactFromObject } from "../backends/wasm/src/wasm.mjs";
 import { inputPatternForObjectRelation } from "../backends/llvm/src/executable.mjs";
 
+function printHelp() {
+  console.log(`Usage: node scripts/perf-poly.mjs [options]
+
+Polymorphic List Operations Benchmark Harness.
+Benchmarks reverse, concat, split_by, get_nth, and length on
+Examples/poly.k across Native JS, kVM interpreter, LLVM, Wasm, and ARM64.
+
+Options:
+  --trace
+      Enable 7-phase nanosecond execution timing.
+  --profile
+      Enable per-function call count profiling.
+  --wasm-in-process
+      Run WebAssembly in-process instead of persistent subprocess runner.
+  -h, --help
+      Show this help message and exit.
+
+Environment Variables:
+  BACKENDS
+      Target backend to run: 'llvm', 'wasm', or 'arm64'.
+  LLVM_ONLY
+      Run only LLVM backend ('1' to enable).
+  WASM_ONLY
+      Run only WebAssembly backend ('1' to enable).
+  ARM64_ONLY
+      Run only ARM64 backend ('1' to enable).
+  BACKENDS_ONLY
+      Skip JS and kVM interpreter baselines ('1' to enable).
+  LIST_LENGTH
+      Workload size for list operations (default: 40).
+  ITERATIONS
+      Measured iterations per benchmark (default: 3).
+  TRACE, K_TRACE
+      Enable nanosecond execution tracing ('1' to enable).
+  PROFILE, K_PROFILE
+      Enable per-function call count profiling ('1' to enable).
+  ARM64_WARMUP_ITERATIONS
+      Warmup iterations for ARM64 backend (default: 1).
+  ARM64_OPT
+      ARM64 backend optimization flags (default: -O2).
+  ARM64_SPAWN_PER_CALL
+      Spawn process per ARM64 call instead of persistent ('1' or '0').
+  ARM64_PIPELINE
+      Use persistent pipelined runner for ARM64 ('1' or '0').
+  LLVM_WARMUP_ITERATIONS
+      Warmup iterations for LLVM backend (default: 1).
+  LLVM_SPAWN_PER_CALL
+      Spawn process per LLVM call instead of persistent ('1' or '0').
+  LLVM_PIPELINE
+      Use persistent pipelined runner for LLVM ('1' or '0').
+  K_LLVM_CACHE_DIR
+      Directory to cache compiled LLVM executable binaries.
+  WASM_WARMUP_ITERATIONS
+      Warmup iterations for WebAssembly backend (default: 3).
+  WASM_RESET
+      Reset WebAssembly memory between iterations (default: 1).
+  WASM_PIPE
+      Use persistent subprocess for Wasm (default: 1, '0': in-process).
+  WASM_IN_PROCESS
+      Run WebAssembly in-process ('1' to enable).`);
+}
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  printHelp();
+  process.exit(0);
+}
+
 // Backend selection
 const backendsEnv = process.env.BACKENDS?.toLowerCase();
 const llvmOnly = process.env.LLVM_ONLY === "1" || backendsEnv === "llvm";
@@ -126,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/scripts/render-benchmark.mjs

@@ -5,6 +5,31 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+function printHelp() {
+  console.log(
+`Usage: node scripts/render-benchmark.mjs [in.json] [out.html]
+
+Renders benchmark results JSON into a standalone interactive HTML report.
+
+Arguments:
+  input-json
+      Path to benchmark results JSON file.
+      (default: benchmark-results.json)
+  output-html
+      Destination path for generated HTML report.
+      (default: benchmark-results.html)
+
+Options:
+  -h, --help
+      Show this help message and exit.`);
+}
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  printHelp();
+  process.exit(0);
+}
+
 const inputPath = path.resolve(root, process.argv[2] || "benchmark-results.json");
 const outputPath = path.resolve(root, process.argv[3] || "benchmark-results.html");
 

package/scripts/run-tests.mjs

@@ -7,6 +7,24 @@ import { fileURLToPath } from "node:url";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const node = process.execPath;
+
+function printHelp() {
+  console.log(`Usage: node scripts/run-tests.mjs [options]
+
+Runs the comprehensive K language test suite, including core unit tests,
+type derivation, codecs, object encoding, conformance, REPL, interpreter,
+and arithmetic suites.
+
+Options:
+  -h, --help
+      Show this help message and exit.`);
+}
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  printHelp();
+  process.exit(0);
+}
+
 const derivationTests = fs.readdirSync(path.join(root, "tests/code-derivation"))
   .filter((name) => name.endsWith(".mjs"))
   .sort()
@@ -31,6 +49,7 @@ const tests = [
   ["tests/test-kvm.mjs", node, ["tests/test-kvm.mjs"]],
   ["tests/test-kvm-polymorphic.mjs", node, ["tests/test-kvm-polymorphic.mjs"]],
   ["tests/test-arithmetics.mjs", node, ["tests/test-arithmetics.mjs"]],
+  ["tests/test-karatsuba.mjs", node, ["tests/test-karatsuba.mjs"]],
   ["tests/test-poly.mjs", node, ["tests/test-poly.mjs"]],
   ["tests/test-ieee-arithmetic.mjs", node, ["tests/test-ieee-arithmetic.mjs"]],
   ["tests/integration.sh", path.join(root, "tests/integration.sh"), []]

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-karatsuba.mjs

@@ -0,0 +1,133 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(scriptDir, "..");
+const node = process.execPath;
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-karatsuba-"));
+const libPath = path.join(tmpDir, "karatsuba-mult.klib");
+const kSource = path.join(root, "Examples/karatsuba-mult.k");
+const program = "{() x, () y} karatsuba";
+
+const smallInput =
+  "111111122222233333344444445555556666667777777888888999999000000" +
+  "11111122222233333344444455555";
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: root,
+    input: options.input,
+    encoding: options.encoding ?? null,
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (result.error && result.status == null) throw result.error;
+  return result;
+}
+
+function assertOk(result, label) {
+  if (result.status !== 0) {
+    const stderr = Buffer.isBuffer(result.stderr)
+      ? result.stderr.toString("utf8")
+      : String(result.stderr ?? "");
+    const stdout = Buffer.isBuffer(result.stdout)
+      ? result.stdout.toString("utf8")
+      : String(result.stdout ?? "");
+    assert.fail(
+      `${label} failed (status ${result.status})\n` +
+      `STDERR:\n${stderr}\nSTDOUT:\n${stdout}`
+    );
+  }
+}
+
+function parseIntWire(text) {
+  const result = run(node, ["codecs/int.mjs", "--parse"], {
+    input: `${text}\n`
+  });
+  assertOk(result, `parse int ${text}`);
+  return result.stdout;
+}
+
+function printIntWire(wire, label) {
+  const result = run(node, ["codecs/int.mjs", "--print"], {
+    input: wire,
+    encoding: "utf8"
+  });
+  assertOk(result, `${label} print`);
+  return result.stdout.trim();
+}
+
+function runKaratsuba(inputText) {
+  const wire = parseIntWire(inputText);
+  const result = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "karatsuba:karatsuba",
+    program
+  ], { input: wire });
+  assertOk(result, `native karatsuba(${inputText})`);
+  return printIntWire(result.stdout, `native karatsuba`);
+}
+
+function expectedSquare(inputText) {
+  const n = BigInt(inputText);
+  return (n * n).toString();
+}
+
+try {
+  assertOk(
+    run(node, ["objects/compile.mjs", kSource, libPath], {
+      encoding: "utf8"
+    }),
+    "compile Examples/karatsuba-mult.k"
+  );
+
+  const testInputs = [
+    "0",
+    "1",
+    "-1",
+    "7",
+    "-7",
+    "42",
+    "-42",
+    "123456789",
+    "-123456789",
+    "987654321987654321",
+    "-987654321987654321",
+    smallInput,
+    `-${smallInput}`
+  ];
+
+  for (const input of testInputs) {
+    assert.equal(
+      runKaratsuba(input),
+      expectedSquare(input),
+      `karatsuba square(${input.slice(0, 20)}...) mismatch`
+    );
+  }
+
+  // Test asymmetric pair multiplication with mixed signs via int list
+  const pairWire = parseIntWire(
+    "[12345678901234567890, -98765432109876543210]"
+  );
+  const pairProgram = "/cons { .car x, .cdr /cons .car y } karatsuba";
+  const resPair = run(node, [
+    "k.mjs",
+    "--lib", libPath,
+    "--export", "karatsuba:karatsuba",
+    pairProgram
+  ], { input: pairWire });
+  assertOk(resPair, "pair multiplication");
+  assert.equal(
+    printIntWire(resPair.stdout, "pair multiplication"),
+    (12345678901234567890n * -98765432109876543210n).toString(),
+    "asymmetric pair multiplication should match BigInt oracle"
+  );
+
+  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");