@fraczak/k 7.0.0 → 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

@@ -8,6 +8,7 @@ import { compileObject, decodeObject, hydrateObject } from "./object.mjs";
 import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
 import { propertyListToFilter } from "./codecs/runtime/show-value.mjs";
+import { TypePatternGraph } from "./TypePatternGraph.mjs";
 
 const KIR_FORMAT = "k-ir";
 const KIR_VERSION = 1;
@@ -240,6 +241,11 @@ function resolveRelation(object, relationName = null) {
   const alias = object.relAlias?.[name];
   if (alias && object.rels?.[alias]) return { name: alias, rel: object.rels[alias] };
   if (alias && object.rels?.[name]) return { name, rel: object.rels[name] };
+  if (alias) {
+    for (const [k, rel] of Object.entries(object.rels || {})) {
+      if (object.relAlias?.[k] === alias) return { name: k, rel };
+    }
+  }
 
   throw new Error(`Relation '${name}' not found`);
 }
@@ -264,7 +270,274 @@ function relationLibraryWithTarget(object, targetRel) {
   };
 }
 
-function relationPatternPropertyList(rel, index) {
+function addPropertyListToPatternGraph(graph, propertyList) {
+  const kindToPattern = {
+    any: "(...)",
+    "open-product": "{...}",
+    "open-union": "<...>",
+    "closed-product": "{}",
+    "closed-union": "<>"
+  };
+  const nodes = propertyList.map(([kind]) =>
+    graph.addNewNode({ pattern: kindToPattern[kind] })
+  );
+
+  propertyList.forEach(([, edges], nodeIndex) => {
+    for (const [label, target] of edges) {
+      graph.edges[nodes[nodeIndex]][label] = [nodes[target]];
+    }
+  });
+
+  return nodes[0];
+}
+
+function cloneRelation(rel) {
+  const clonedGraph = new TypePatternGraph(
+    rel.typePatternGraph.registerCodeDef,
+    rel.typePatternGraph.findCode
+  );
+  clonedGraph.patterns.nodes = JSON.parse(JSON.stringify(rel.typePatternGraph.patterns.nodes));
+  clonedGraph.patterns.parent = [...rel.typePatternGraph.patterns.parent];
+  clonedGraph.edges = JSON.parse(JSON.stringify(rel.typePatternGraph.edges));
+  clonedGraph.codeId = { ...rel.typePatternGraph.codeId };
+
+  return {
+    ...rel,
+    def: JSON.parse(JSON.stringify(rel.def)),
+    typePatternGraph: clonedGraph,
+    typeDerivation: { ...(rel.typeDerivation || {}) }
+  };
+}
+
+function findCallSites(exp) {
+  const calls = [];
+  function visit(node) {
+    if (!node) return;
+    if (node.op === "ref") calls.push(node);
+    if (node.comp) node.comp.forEach(visit);
+    if (node.items) node.items.forEach(visit);
+    if (node.union) node.union.forEach(visit);
+    if (node.product) node.product.forEach((item) => visit(item.exp));
+    if (node.fields) node.fields.forEach((item) => visit(item.expr));
+  }
+  visit(exp);
+  return calls;
+}
+
+function findRelation(rels, relAlias, name) {
+  if (!name) return null;
+  if (rels[name]) return { name, rel: rels[name] };
+  const alias = relAlias?.[name];
+  if (alias && rels[alias]) return { name: alias, rel: rels[alias] };
+  if (alias) {
+    for (const [k, rel] of Object.entries(rels)) {
+      if (relAlias?.[k] === alias) return { name: k, rel };
+    }
+  }
+  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");
+  }
+
+  const baseRels = Object.fromEntries(
+    Object.entries(object.rels || {}).map(([name, rel]) => [name, cloneRelation(rel)])
+  );
+  for (const [aliasName, hash] of Object.entries(object.relAlias || {})) {
+    if (!baseRels[aliasName]) {
+      const match = Object.entries(baseRels).find(([k]) => object.relAlias?.[k] === hash);
+      if (match) baseRels[aliasName] = match[1];
+    }
+  }
+
+  const entry = findRelation(
+    baseRels,
+    object.relAlias,
+    entryRelationName || object.main || "__main__"
+  );
+  if (!entry) return object;
+
+  const specializedRels = new Map();
+  const specializedCounts = new Map();
+  const newRels = {};
+  const inProgress = new Map();
+  let entryCandidate = null;
+
+  function specializeRelation(relName, argPropList) {
+    const target = findRelation(baseRels, object.relAlias, relName);
+    if (!target) return relName;
+
+    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);
+    }
+
+    const count = (specializedCounts.get(target.name) || 0) + 1;
+    const specName = `${target.name}$${count}`;
+    inProgress.set(specKey, specName);
+
+    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 = candidateRel.typePatternGraph.find(argPatternId);
+        const childArgPropList = patternToPropertyList(
+          exportPatternGraph(candidateRel.typePatternGraph, argRoot)
+        );
+        const childSpecName = specializeRelation(call.ref, childArgPropList);
+        if (childSpecName !== call.ref) {
+          call.ref = childSpecName;
+          anyCallChanged = true;
+        }
+
+        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 = {
+    ...baseRels,
+    ...newRels
+  };
+  const resultRelAlias = { ...(object.relAlias || {}) };
+  for (const name of Object.keys(newRels)) {
+    if (!resultRelAlias[name]) resultRelAlias[name] = name;
+  }
+
+  return {
+    ...object,
+    rels: resultRels,
+    relAlias: resultRelAlias
+  };
+}
+
+export function relationPatternPropertyList(rel, index) {
   return expPatternPropertyList(rel, rel.def, index);
 }
 
@@ -284,28 +557,35 @@ export function retypeObjectRelationForBackend(object, relationName, inputPatter
   }
 
   const target = resolveRelation(object, relationName);
-  const source = `?${propertyListToFilter(inputPattern)} __kir_target__`;
-  const retypedObject = hydrateObject(compileObject(source, {
-    source: options.source || "<kir-retype>",
-    libraries: [relationLibraryWithTarget(object, target.rel)]
-  }));
-  const kir = objectToKIRP(retypedObject);
-  const entryName = retypedObject.main || "__main__";
-  const retypedRel = retypedObject.rels[entryName];
-  const entryInputPattern = relationPatternPropertyList(retypedRel, 0);
+  const specializedObject = specializeObjectRelations(object, target.name, inputPattern);
+  const specializedRel = resolveRelation(specializedObject, target.name);
+  const kir = objectToKIRP(specializedObject);
 
   return {
-    relation: relationName || object.main,
-    retypedObject,
+    relation: target.name,
+    retypedObject: specializedObject,
     kir,
-    entryName,
-    inputPattern: entryInputPattern,
-    outputPattern: relationPatternPropertyList(retypedRel, 1)
+    entryName: target.name,
+    inputPattern: relationPatternPropertyList(specializedRel.rel, 0),
+    outputPattern: relationPatternPropertyList(specializedRel.rel, 1)
   };
 }
 
 export function retypeObjectRelation(object, relationName, inputPattern, options = {}) {
-  return retypeObjectRelationForBackend(object, relationName, inputPattern, options).kir;
+  if (object?.format !== "k-object") {
+    throw new Error("KIR retyping requires a k object");
+  }
+  if (!Array.isArray(inputPattern)) {
+    throw new Error("KIR retyping requires an input pattern property list");
+  }
+
+  const target = resolveRelation(object, relationName);
+  const source = `?${propertyListToFilter(inputPattern)} __kir_target__`;
+  const retypedObject = hydrateObject(compileObject(source, {
+    source: options.source || "<kir-retype>",
+    libraries: [relationLibraryWithTarget(object, target.rel)]
+  }));
+  return objectToKIRP(retypedObject);
 }
 
 export { KIR_FORMAT, KIR_VERSION };
@@ -314,8 +594,10 @@ export default {
   KIR_FORMAT,
   KIR_VERSION,
   objectToKIRP,
+  relationPatternPropertyList,
   retypeObjectRelation,
-  retypeObjectRelationForBackend
+  retypeObjectRelationForBackend,
+  specializeObjectRelations
 };
 
 function helpText() {

package/package.json

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