@fraczak/k 7.0.1 → 7.0.2

package/core.k

@@ -1,17 +1,17 @@
 -- core.k — the k standard core library
 --
 -- Defines:
---   1. bits — canonical binary number / bit-path relation
---   2. string — unicode strings relation (used for labels)
---   3. pattern — pattern graph relation
+--   1. bits? — canonical binary number / bit-path relation
+--   2. string? — unicode strings relation (used for labels)
+--   3. pattern? — pattern graph relation
 
 ---------------------------------------------------------------
 -- §1. Bits
 ---------------------------------------------------------------
 
-bit = ?< {} 0, {} 1 >;
+bit? = ?< {} 0, {} 1 >;
 
-bits = ?< {} _, bits 0, bits 1 > = bits;
+bits? = ?< {} _, bits? 0, bits? 1 > = bits?;
 
 _ = {}|_;
 
@@ -22,7 +22,7 @@ _ = {}|_;
 -- §2. Unicode and String
 ---------------------------------------------------------------
 
-string = ? <
+string? = ? <
   {} nil,
   {
     <
@@ -82,7 +82,7 @@ string = ? <
 -- to decode any value, first decode a pattern under that constant,
 -- then decode the value under the pattern just obtained.
 
-pattern = ? <
+pattern? = ? <
   {} nil,
   {
     <
@@ -150,4 +150,4 @@ pattern = ? <
   } cons
 > = Pattern;
 
-pattern
+pattern?

package/harness/format.mjs

@@ -1,6 +1,6 @@
 import { PHASES, formatUs } from "./trace.mjs";
 
-export function formatPhaseTable(phaseResults, backendIds = ["arm64", "llvm", "wasm", "kvm"]) {
+export function formatPhaseTable(phaseResults, backendIds = ["llvm", "wasm", "kvm"]) {
   const lines = [];
 
   for (const item of phaseResults) {
@@ -25,7 +25,7 @@ export function formatPhaseTable(phaseResults, backendIds = ["arm64", "llvm", "w
   return lines.join("\n");
 }
 
-export function formatProfileTable(profileResults, backendIds = ["arm64", "wasm", "kvm"]) {
+export function formatProfileTable(profileResults, backendIds = ["wasm", "kvm"]) {
   const lines = [];
 
   for (const item of profileResults) {

package/harness/registry.mjs

@@ -1,7 +1,6 @@
 import { NativeAdapter } from "./adapters/native.mjs";
 import { KVMAdapter } from "./adapters/kvm.mjs";
 import { WasmAdapter } from "./adapters/wasm.mjs";
-import { ARM64Adapter } from "./adapters/arm64.mjs";
 import { LLVMAdapter } from "./adapters/llvm.mjs";
 
 export function createRegistry(config = {}) {
@@ -16,7 +15,6 @@ export function createRegistry(config = {}) {
   register("kvm", () => new KVMAdapter(config.state));
   register("wasm", () => new WasmAdapter(config.wasm || {}));
   register("wasm-in-process", () => new WasmAdapter({ id: "wasm-in-process", mode: "in-process", ...(config.wasm || {}) }));
-  register("arm64", () => new ARM64Adapter(config.arm64 || {}));
   register("llvm", () => new LLVMAdapter(config.llvm || {}));
 
   return {

package/kir.mjs

@@ -337,6 +337,64 @@ function findRelation(rels, relAlias, name) {
   return null;
 }
 
+function findDots(exp, res = []) {
+  if (!exp || typeof exp !== "object") return res;
+  if (exp.op === "dot") res.push(exp);
+  if (Array.isArray(exp.comp)) exp.comp.forEach((c) => findDots(c, res));
+  if (Array.isArray(exp.items)) exp.items.forEach((c) => findDots(c, res));
+  if (Array.isArray(exp.union)) exp.union.forEach((c) => findDots(c, res));
+  if (Array.isArray(exp.product)) {
+    exp.product.forEach((c) => findDots(c?.exp || c?.expr, res));
+  }
+  if (Array.isArray(exp.fields)) {
+    exp.fields.forEach((c) => findDots(c?.expr || c?.exp, res));
+  }
+  return res;
+}
+
+function getDotIndex(rel, dotExp) {
+  const label = dotExp.dot || dotExp.label;
+  if (!label) return -1;
+  const propList = expPatternPropertyList(rel, dotExp, 0);
+  if (Array.isArray(propList?.[0]?.[1])) {
+    return propList[0][1].findIndex(([l]) => l === label);
+  }
+  return -1;
+}
+
+function relationLayoutSignature(rel) {
+  const inPropList = relationPatternPropertyList(rel, 0);
+  if (!Array.isArray(inPropList)) return "";
+
+  const dots = findDots(rel.def);
+  const dotIndices = dots.map((d) => {
+    const lbl = d.dot || d.label || "";
+    return `${lbl}:${getDotIndex(rel, d)}`;
+  });
+
+  const productShapes = [];
+  for (const [kind, edges] of inPropList) {
+    if (kind === "open-product" || kind === "closed-product") {
+      const fieldNames = edges.map(([l]) => l).sort().join(",");
+      if (fieldNames.length > 0) productShapes.push(fieldNames);
+    }
+  }
+
+  return dotIndices.join(",") + "|" + productShapes.sort().join(";");
+}
+
+function productShapeSignature(propList) {
+  if (!Array.isArray(propList)) return "";
+  const shapes = [];
+  for (const [kind, edges] of propList) {
+    if (kind === "open-product" || kind === "closed-product") {
+      const fieldNames = edges.map(([l]) => l).sort().join(",");
+      if (fieldNames.length > 0) shapes.push(fieldNames);
+    }
+  }
+  return shapes.sort().join(";");
+}
+
 export function specializeObjectRelations(object, entryRelationName = null, inputPattern = null) {
   if (object?.format !== "k-object") {
     throw new Error("specializeObjectRelations requires a k object");
@@ -362,77 +420,105 @@ export function specializeObjectRelations(object, entryRelationName = null, inpu
   const specializedRels = new Map();
   const specializedCounts = new Map();
   const newRels = {};
+  const inProgress = new Map();
+  let entryCandidate = null;
 
-  const entryRel = cloneRelation(entry.rel);
-  newRels[entry.name] = entryRel;
+  function specializeRelation(relName, argPropList) {
+    const target = findRelation(baseRels, object.relAlias, relName);
+    if (!target) return relName;
 
-  if (Array.isArray(inputPattern) && inputPattern.length > 0) {
-    const inRoot = addPropertyListToPatternGraph(entryRel.typePatternGraph, inputPattern);
-    try {
-      entryRel.typePatternGraph.unify("specialize", entryRel.def.patterns[0], inRoot);
-    } catch {
-      // Best-effort entry unification
+    const baseInSig = relationLayoutSignature(target.rel);
+    const shapeSig = productShapeSignature(argPropList);
+    const specKey = target.name + "::" + shapeSig;
+
+    if (specializedRels.has(specKey)) {
+      return specializedRels.get(specKey);
+    }
+    if (inProgress.has(specKey)) {
+      return inProgress.get(specKey);
     }
-    specializedRels.set(entry.name + "::" + JSON.stringify(inputPattern), entry.name);
-  }
 
-  const worklist = [entry.name];
-  while (worklist.length > 0) {
-    const currentName = worklist.shift();
-    const currentRel = newRels[currentName];
-    if (!currentRel) continue;
+    const count = (specializedCounts.get(target.name) || 0) + 1;
+    const specName = `${target.name}$${count}`;
+    inProgress.set(specKey, specName);
 
-    const calls = findCallSites(currentRel.def);
-    for (const call of calls) {
-      const target = findRelation(baseRels, object.relAlias, call.ref);
-      if (!target) continue;
+    const candidateRel = cloneRelation(target.rel);
+    if (!candidateRel.typeDerivation) candidateRel.typeDerivation = {};
+    if (!candidateRel.typeDerivation.status) {
+      candidateRel.typeDerivation.status = target.rel?.typeDerivation?.status || "converged";
+    }
+
+    if (Array.isArray(argPropList) && argPropList.length > 0) {
+      const tInRoot = addPropertyListToPatternGraph(candidateRel.typePatternGraph, argPropList);
+      try {
+        candidateRel.typePatternGraph.unify("specialize", candidateRel.def.patterns[0], tInRoot);
+      } catch {
+        // Unification failure: keep target unspecialized
+      }
+    }
+
+    if (relName === entry.name && (!entryCandidate || Array.isArray(argPropList))) {
+      entryCandidate = candidateRel;
+    }
 
+    let anyCallChanged = false;
+    const calls = findCallSites(candidateRel.def);
+    for (const call of calls) {
       const argPatternId = call.patterns?.[0];
       if (argPatternId != null) {
-        const argRoot = currentRel.typePatternGraph.find(argPatternId);
-        const argPropList = patternToPropertyList(
-          exportPatternGraph(currentRel.typePatternGraph, argRoot)
+        const argRoot = candidateRel.typePatternGraph.find(argPatternId);
+        const childArgPropList = patternToPropertyList(
+          exportPatternGraph(candidateRel.typePatternGraph, argRoot)
         );
-        const argSig = JSON.stringify(argPropList);
-        const specKey = target.name + "::" + argSig;
-
-        let specName = specializedRels.get(specKey);
-        if (!specName) {
-          const count = (specializedCounts.get(target.name) || 0) + 1;
-          specializedCounts.set(target.name, count);
-          specName = count === 1 ? target.name : `${target.name}$${count}`;
-          specializedRels.set(specKey, specName);
-
-          const targetRel = cloneRelation(target.rel);
-          const tInRoot = addPropertyListToPatternGraph(targetRel.typePatternGraph, argPropList);
-          try {
-            targetRel.typePatternGraph.unify("specialize", targetRel.def.patterns[0], tInRoot);
-          } catch {
-            // Unification failure: keep target unspecialized
-          }
-          newRels[specName] = targetRel;
-          worklist.push(specName);
+        const childSpecName = specializeRelation(call.ref, childArgPropList);
+        if (childSpecName !== call.ref) {
+          call.ref = childSpecName;
+          anyCallChanged = true;
         }
 
-        call.ref = specName;
-
-        const targetRel = newRels[specName];
-        const outPatternId = targetRel.def.patterns?.[1];
-        const retPatternId = call.patterns?.[1];
-        if (outPatternId != null && retPatternId != null) {
-          const outRoot = targetRel.typePatternGraph.find(outPatternId);
-          const retPropList = patternToPropertyList(
-            exportPatternGraph(targetRel.typePatternGraph, outRoot)
-          );
-          const rRetRoot = addPropertyListToPatternGraph(currentRel.typePatternGraph, retPropList);
-          try {
-            currentRel.typePatternGraph.unify("specialize", retPatternId, rRetRoot);
-          } catch {
-            // Keep existing call return pattern on unification error
+        const childRel = newRels[childSpecName] || baseRels[childSpecName];
+        if (childRel) {
+          const outPatternId = childRel.def.patterns?.[1];
+          const retPatternId = call.patterns?.[1];
+          if (outPatternId != null && retPatternId != null) {
+            const outRoot = childRel.typePatternGraph.find(outPatternId);
+            const retPropList = patternToPropertyList(
+              exportPatternGraph(childRel.typePatternGraph, outRoot)
+            );
+            const rRetRoot = addPropertyListToPatternGraph(candidateRel.typePatternGraph, retPropList);
+            try {
+              candidateRel.typePatternGraph.unify("specialize", retPatternId, rRetRoot);
+            } catch {
+              // Keep existing call return pattern on unification error
+            }
           }
         }
       }
     }
+
+    inProgress.delete(specKey);
+
+    const newInSig = relationLayoutSignature(candidateRel);
+    const isDifferent = (newInSig !== baseInSig) || anyCallChanged;
+
+    if (!isDifferent) {
+      specializedRels.set(specKey, target.name);
+      return target.name;
+    }
+
+    specializedCounts.set(target.name, count);
+    specializedRels.set(specKey, specName);
+    newRels[specName] = candidateRel;
+    return specName;
+  }
+
+  const entrySpecName = specializeRelation(entry.name, inputPattern);
+  if (entrySpecName !== entry.name && newRels[entrySpecName]) {
+    newRels[entry.name] = newRels[entrySpecName];
+  } else if (entryCandidate) {
+    newRels[entry.name] = entryCandidate;
+  } else if (!newRels[entry.name]) {
+    newRels[entry.name] = baseRels[entry.name];
   }
 
   const resultRels = {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "7.0.1",
+    "version": "7.0.2",
     "description": "k — a language for content-addressable schemas and data transformations over algebraic data types (products and tagged unions); includes runtime, contract derivation, REPL, and codec toolchain",
     "publishConfig": {
         "access": "public"
@@ -16,7 +16,6 @@
         "test:backends": "node backends/llvm/scripts/run-tests.mjs && node backends/wasm/scripts/run-tests.mjs",
         "test:llvm": "node backends/llvm/scripts/run-tests.mjs",
         "test:wasm": "node backends/wasm/scripts/run-tests.mjs",
-        "test:arm64": "node backends/arm64/scripts/run-tests.mjs",
         "conformance": "node conformance/run.mjs",
         "benchmark": "node scripts/benchmark.mjs",
         "benchmark:html": "node scripts/render-benchmark.mjs",
@@ -49,9 +48,6 @@
         "k-llvm-compile": "backends/llvm/bin/k-llvm-compile.mjs",
         "k-llvm-jit": "backends/llvm/bin/k-llvm-jit.mjs",
         "k-llvm-run": "backends/llvm/bin/k-llvm-run.mjs",
-        "k-arm64": "backends/arm64/bin/k-arm64.mjs",
-        "k-arm64-compile": "backends/arm64/bin/k-arm64-compile.mjs",
-        "k-arm64-run": "backends/arm64/bin/k-arm64-run.mjs",
         "k-wasm": "backends/wasm/bin/k-wasm.mjs",
         "k-wasm-compile": "backends/wasm/bin/k-wasm-compile.mjs",
         "k-wasm-run": "backends/wasm/bin/k-wasm-run.mjs",

package/scripts/benchmark-idempotency.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { spawnSync } from "node:child_process";
-import { mkdtempSync, statSync } from "node:fs";
+import { mkdtempSync, rmSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { performance } from "node:perf_hooks";
@@ -80,13 +80,17 @@ for (const example of benchmarkExamples) {
 
   for (let i = 0; i < iterations; i++) {
     const out = mkdtempSync(join(tmpdir(), `k-idempotency-bench-${example.replaceAll("/", "_")}-`));
-    const t0 = performance.now();
-    run(["objects/compile.mjs", example, join(out, "1.klib")]);
-    run(["objects/decompile.mjs", join(out, "1.klib"), join(out, "1.k")]);
-    run(["objects/compile.mjs", join(out, "1.k"), join(out, "2.klib")]);
-    run(["objects/decompile.mjs", join(out, "2.klib"), join(out, "2.k")]);
-    times.push(performance.now() - t0);
-    size = statSync(join(out, "1.klib")).size;
+    try {
+      const t0 = performance.now();
+      run(["objects/compile.mjs", example, join(out, "1.klib")]);
+      run(["objects/decompile.mjs", join(out, "1.klib"), join(out, "1.k")]);
+      run(["objects/compile.mjs", join(out, "1.k"), join(out, "2.klib")]);
+      run(["objects/decompile.mjs", join(out, "2.klib"), join(out, "2.k")]);
+      times.push(performance.now() - t0);
+      size = statSync(join(out, "1.klib")).size;
+    } finally {
+      rmSync(out, { recursive: true, force: true });
+    }
   }
 
   console.log([

package/scripts/benchmark.mjs

@@ -21,13 +21,12 @@ import {
   retypeObjectRelationForBackend,
   patternToPropertyList,
   propertyListToPattern,
-  parseFloat64,
   run,
   run_converged,
-  valueForCode,
   Value
 } from "../backend-api.mjs";
 import { parse as parseIntValue } from "../codecs/int.mjs";
+import { parse as parseFloatValue } from "../codecs/ieee.mjs";
 import {
   compileObjectBuffer as compileBackendObjectBuffer,
   decodeObject as decodeBackendObject
@@ -460,13 +459,10 @@ async function prepareState(suite) {
 }
 
 function ieeeInput(testCase, state) {
-  const float64Hash = state.typeAliases.float64;
-  const floatPairHash = state.typeAliases.float_pair;
-  const float64 = text => valueForCode(parseFloat64(text), float64Hash, codes.find);
-  return valueForCode(Value.product({
-    x: float64(testCase.input.x),
-    y: float64(testCase.input.y)
-  }), floatPairHash, codes.find);
+  return Value.product({
+    x: parseFloatValue(testCase.input.x),
+    y: parseFloatValue(testCase.input.y)
+  });
 }
 
 function arithmeticInput(testCase) {

package/scripts/build-repl-html.mjs

@@ -1888,8 +1888,8 @@ const htmlContent = `<!DOCTYPE html>
               <li><code>{} | ok</code> &mdash; Constant relation producing variant <code>ok</code> with empty document payload <code>{}</code></li>
               <li><code>not = &lt; / true | false, / false | true &gt;;</code> &mdash; Polymorphic negation via branch projections and ordered choice</li>
               <li><code>{} | true not</code> &mdash; Compose constant relation <code>{} | true</code> with <code>not</code> (evaluates to <code>{} | false</code>)</li>
-              <li><code>bool = ?&lt; {} true, {} false &gt;;</code> &mdash; Define a boolean pattern filter relation</li>
-              <li><code>not = bool ?X &lt; / true | false, {} | true &gt; ?X;</code> &mdash; Filtered boolean negation: guarded by <code>bool</code>, defaulting to <code>{} | true</code></li>
+              <li><code>bool? = ?&lt; {} true, {} false &gt;;</code> &mdash; Define a boolean pattern filter relation</li>
+              <li><code>not = bool? ?X &lt; / true | false, {} | true &gt; ?X;</code> &mdash; Filtered boolean negation: guarded by <code>bool?</code>, defaulting to <code>{} | true</code></li>
               <li><code>swap = { . y x, . x y };</code> &mdash; Define a product field-swapping relation</li>
               <li><code>{ {} | ok x, {} | nil y } swap</code> &mdash; Construct a product and pass it through <code>swap</code></li>
             </ul>