@fraczak/k 6.10.6 → 7.0.1

package/Examples/karatsuba-mult.k

@@ -2,23 +2,22 @@
 -- Self-contained and minimal implementation
 -- for arbitrary-precision integers
 
-$ yes_no = < {} yes, {} no >;
-yes = {} | yes $yes_no;
-no = {} | no $yes_no;
+yes = {} | yes;
+no = {} | no;
 
-$ bits = < {} _, bits 0, bits 1 >;
+bits = ?< {} _, bits 0, bits 1 > = bits;
 0b = {} | _;
 0 = 0b |0;
 1 = 0b |1;
 
-$ unat = < {} _, unat 1 >;
-0u = {} | _ $unat;
+unat = ?< {} _, unat 1 > = unat;
+0u = {} | _;
 
-empty = $bits < /_ yes, no >;
+empty = < /_ yes, no >;
 empty? = {empty /yes if, () then} .then;
 
 inv = {()x, 0b r} _inv;
-_inv = ${bits x, bits r}
+_inv = ?{ <X 0, X 1, {} _>=X x, ... }
 <
   {.x empty? if, .r then} .then,
   <
@@ -27,8 +26,8 @@ _inv = ${bits x, bits r}
   > _inv
 >;
 
-concat = ${bits x, bits y} {.x inv x, .y y} concat_;
-concat_ = ${bits x, bits y}
+concat = {.x inv x, .y y} concat_;
+concat_ = ?{ <X 0, X 1, {} _>=X x, ... }
 <
   {.x empty? if, .y then} .then,
   <
@@ -40,21 +39,18 @@ concat_ = ${bits x, bits y}
 remove_leading_zeros = < /0 remove_leading_zeros, () >;
 nat = remove_leading_zeros <empty? 0, ()>;
 
-$ int = < bits '+', bits '-' >;
-int = nat | '+' $int;
-abs = $int </'+', /'-'>;
+int = nat | '+';
+abs = </'+', /'-'>;
 
-$ sign = < {} '+', {} '-' >;
-sign_plus = {} | '+' $sign;
-sign_minus = {} | '-' $sign;
+sign_plus = {} | '+';
+sign_minus = {} | '-';
 swap_sign = < /'+' | '-', /'-' | '+' >;
 
-$ carry = < {} 0, {} 1 >;
-c0 = {} | 0 $carry;
-c1 = {} | 1 $carry;
+c0 = {} | 0;
+c1 = {} | 1;
 
 _plus = {.x x, .y y, .c c, 0b r} _plus_;
-_plus_ = ${bits x, bits y, carry c, bits r}
+_plus_ = ?{ <X 0, X 1, {} _>=X x, ... }
 <
   {.x empty? if, .y empty? and, .c/0 c, .r inv then} .then,
   {.x empty? if, .y empty? and, {.r x, 1 r} _inv then} .then,
@@ -74,7 +70,7 @@ _plus_ = ${bits x, bits y, carry c, bits r}
 >;
 
 _minus = {.x x, .y y, .c c, 0b r} _minus_;
-_minus_ = ${bits x, bits y, carry c, bits r}
+_minus_ = ?{ <X 0, X 1, {} _>=X x, ... }
 <
   {.y empty? if, .c/0 and, {.r x, .x r} _inv then} .then,
   <
@@ -91,10 +87,10 @@ _minus_ = ${bits x, bits y, carry c, bits r}
   > _minus_
 >;
 
-plus_bits = ${bits x, bits y} {.x inv x, .y inv y, c0 c} _plus inv nat;
-minus_bits = ${bits x, bits y} {.x inv x, .y inv y, c0 c} _minus inv nat;
+plus_bits = {.x inv x, .y inv y, c0 c} _plus inv nat;
+minus_bits = {.x inv x, .y inv y, c0 c} _minus inv nat;
 
-_times = ${bits result, bits _x, bits y}
+_times = ?{ <Y 0, Y 1, {} _>=Y y, ... }
 <
   {.y empty? if, .result then} .then,
   <
@@ -102,21 +98,21 @@ _times = ${bits result, bits _x, bits y}
     {{._x x, .result |0 y, c0 c} _plus result, ._x _x, .y /1 y}
   > _times
 >;
-times_bits = ${bits x, bits y} {0 result, .x inv _x, .y y} _times inv nat;
+times_bits = {0 result, .x inv _x, .y y} _times inv nat;
 
-unat_to_zeros = $unat < /_ 0b, /1 unat_to_zeros |0 > $bits;
-unat_to_double_zeros = $unat
-  < /_ 0b, /1 unat_to_double_zeros |0 |0 > $bits;
+unat_to_zeros = ?< {} _, X 1 >=X < /_ 0b, /1 unat_to_zeros |0 > ?< {} _, Z 0, Z 1 >=Z;
+unat_to_double_zeros = ?< {} _, X 1 >=X
+  < /_ 0b, /1 unat_to_double_zeros |0 |0 > ?< {} _, Z 0, Z 1 >=Z;
 
 _peel2 = < </0,/1> </0,/1>, </0,/1>, () >;
-_half_unat = ${bits x, bits y, unat m}
+_half_unat = ?{ <X 0, X 1, {} _>=X x, ... }
 <
   {.x empty? if, .y empty? and, .m then} .then,
   {.x _peel2 x, .y _peel2 y, .m |1 m} _half_unat
 >;
 half_unat = {.x x, .y y, 0u m} _half_unat;
 
-_split_rev_u = ${bits x_rev, unat m, bits low}
+_split_rev_u = ?{ <X 0, X 1, {} _>=X x_rev, <M 1, {} _>=M m, ... }
 <
   {.m /_ if, {.low nat low, .x_rev inv nat high} then} .then,
   {.x_rev empty? if, {.low nat low, 0 high} then} .then,
@@ -147,19 +143,19 @@ at_least_256_u? = <
   yes, no
 >;
 
-shift_bits_u = ${bits val, unat m}
+shift_bits_u =
 <
   {.val empty? if, 0b then} .then,
   {.val x, .m unat_to_zeros y} concat
 >;
 
-shift2_bits_u = ${bits val, unat m}
+shift2_bits_u =
 <
   {.val empty? if, 0b then} .then,
   {.val x, .m unat_to_double_zeros y} concat
 >;
 
-_karatsuba = ${bits x, bits y}
+_karatsuba = ?{ <X 0, X 1, {} _>=X x, <Y 0, Y 1, {} _>=Y y }
 <
   -- Base case: if m < 256 (< 512 bits), fall back to times_bits
   {{.x x, .y y} half_unat m, .x x, .y y}
@@ -198,7 +194,7 @@ _karatsuba = ${bits x, bits y}
   >
 >;
 
-karatsuba = ${int x, int y}
+karatsuba =
 {
   <
     {.x/'+' if, .y /'+' and} sign_plus,

package/Examples/nat.k

@@ -1,10 +1,9 @@
-$ nat = < {} 0, nat +1 >;
 0 = {} | 0 ;
-0? = $ nat { / 0 if, () then} .then;
-succ = | +1 $ nat ;
-pred = $nat / +1 ;
-add = ?{ $nat x, ... } = X <{.x pred x, .y succ y} ?X add, .y> ;
-mult = <
+0? = { / 0 if, () then} .then;
+succ = | +1 ;
+pred = / +1 ;
+add = ?{ < {} 0, N +1 > = N x, ... } = X <{.x pred x, .y succ y} ?X add, .y> ;
+mult = ?{ < {} 0, M +1 > = M x, ... } <
     {{.x pred x, .y y} mult x, .y y} add,
     0
 > ;

package/README.md

@@ -1,15 +1,15 @@
 # k
 
-**k is a small language for typed data transformations.**
+**k is a small language for content-addressable schemas and data transformations.**
 
-It describes data as algebraic shapes, programs as first-order partial
-functions, and runtime values as a binary `pattern + value` stream
-that can be parsed, transformed, printed, compiled, and inspected.
+It describes data as algebraic schemas, programs as first-order partial
+relations, and runtime values as a self-describing binary `schema + payload`
+stream that can be parsed, transformed, printed, compiled, and inspected.
 
-Data descriptions and transformations share one syntax, so a k file can
-define both the shapes of values and the relations that move between them.
+Schema definitions and transformations share one syntax, so a k file can
+define both data schemas and the relations that transform between them.
 
-k is experimental, but it already has a working parser, type-derivation
+k is experimental, but it already has a working parser, contract-derivation
 engine, REPL, binary codec pipeline, object/library format, Node.js API,
 and test suite.
 
@@ -17,23 +17,23 @@ and test suite.
 
 Many systems need to answer the same questions:
 
-- What shape does this data have?
-- Which transformations are valid for that shape?
-- What does a program accept, produce, or reject?
-- Can this transformation be serialized, tested, reused, or inspected?
+- What schema does this data have?
+- Which transformations are valid for that schema?
+- What does a program accept, produce, or preserve?
+- Can this transformation be serialized, tested, reused, or verified?
 
-k explores a compact answer: define algebraic data shapes, compose
-partial transformations over them, derive input/output patterns
-automatically, and move values across process boundaries with a canonical
-binary representation.
+k explores a compact answer: define algebraic schemas, compose
+partial relations over them, derive input/output contracts
+automatically, and move values across process boundaries with a canonical,
+content-addressable binary representation.
 
 That makes k interesting as a foundation for:
 
-- schema definitions and schema-to-schema transformations
+- content-addressable schema registries and schema-to-schema pipelines
 - binary codecs and canonical serialization
 - protocol, hardware, or test-vector transformation pipelines
-- teaching algebraic data types and compositional programming
-- research into partial functions, finite tree automata, and typed IRs
+- teaching algebraic data types and compositional relational programming
+- research into partial relations, finite tree automata, and typed IRs
 
 ## A Small Example
 
@@ -41,11 +41,10 @@ k can define recursive data and transformations in the same file. Peano
 natural numbers are either `0` or one more than another natural number:
 
 ```k
-$ nat = < {} 0, nat +1 >;
-0 = {} | 0 $ nat ;
-inc = | +1 $ nat ;
-dec = $ nat / +1 ;       # undefined for '0'
-add = $ { nat x, nat y } <
+0 = {} | 0;
+inc = | +1;
+dec = / +1;       # undefined for '0'
+add = ?{ < {} 0, N +1 > = N x, ... } <
   { . x dec x, . y inc y } add,    # defined if 'x > 0'
   . y                              # else, return 'y'
 >;
@@ -53,7 +52,8 @@ add = $ { nat x, nat y } <
 
 `add` takes a product `{ x, y }`. If `x` has a `+1`, it moves that
 successor from `x` to `y` and recurses. When that no longer applies, it
-returns `y`.
+returns `y`. The inductive filter `?{ < {} 0, N +1 > = N x, ... }`
+explicitly witnesses that recursive calls shrink `x`.
 
 In the REPL:
 
@@ -118,12 +118,13 @@ Every installed command supports `-h` and `--help`.
 
 **Algebraic data shapes**
 
-Types, called *codes*, are built from products and tagged unions:
+All data structures in k are built from products and tagged unions (variants).
+Relations and pattern filters describe their domains:
 
 ```k
-$ bit  = < {} 0, {} 1 >;
-$ byte = { bit 0, bit 1, bit 2, bit 3, bit 4, bit 5, bit 6, bit 7 };
-$ bits = < {} _, bits 0, bits 1 >;
+bit  = ?< {} 0, {} 1 >;
+byte = ?{ Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6, Bit 7 };
+bits = ?< {} _, bits 0, bits 1 > = bits;
 ```
 
 There are no built-in primitive values. The empty product `{}` is the
@@ -137,34 +138,38 @@ Core expressions are deliberately small:
 | --- | --- |
 | `.field` | project a product field |
 | `/tag` | project a tagged-union branch |
-| `\|tag` | introduce a tagged-union branch |
+| `\|tag` | introduce a variant (tagged union) |
 | `(f g)` | compose transformations |
 | `<f, g>` | try `f`, then `g` if `f` is undefined |
 | `{f a, g b}` | build a product from parallel transformations |
+| `?filter` | schema filter / inductive termination witness |
 | `()` | identity |
 | `<>` | always undefined |
 | `{}` | constant empty product |
 
-**Derived input/output patterns**
+**Derived relational contracts**
 
-k derives structural constraints for expressions. Those patterns become
-useful for diagnostics, REPL output, binary encoding, and object
-metadata.
+k derives structural contracts for relations. A contract is a connected
+$(input, output)$ schema graph that specifies accepted input schemas,
+guaranteed output schemas, and preserved data structures ($=X$). Those
+contracts guide diagnostics, REPL output, binary serialization, and
+optimizations.
 
-**Binary-friendly runtime values**
+**Self-describing binary streams**
 
 The command-line pipeline uses a self-describing binary stream:
 
 ```text
-encoded pattern, followed by value encoded under that pattern
+encoded schema, followed by payload encoded under that schema
 ```
 
 The boundary tools are:
 
 ```bash
-k-parse   # textual k value -> binary pattern+value stream
+k-parse   # textual k value -> binary schema+payload stream
 k         # apply a k expression or .k/.ko program to the stream
-k-print   # binary pattern+value stream -> textual value
+k-print   # binary schema+payload stream -> textual value
+k-show    # inspect decoded schema and payload value
 ```
 
 **Inspectable objects and libraries**
@@ -172,21 +177,21 @@ k-print   # binary pattern+value stream -> textual value
 `k` programs can be authored, compiled, and linked across four main
 file formats:
 
-- `.k`: human-readable source code defining algebraic types and relations.
-- `.klib`: ahead-of-time (AOT) type-checked library objects (`main: null`)
-  storing canonical relation definitions, type codes, and local aliases.
-- `.ko`: ahead-of-time (AOT) type-checked executable containers (`KOBJ\n`
-  magic header) with entrypoint `main: "__main__"`, skipping parsing and
-  type derivation at runtime.
+- `.k`: human-readable source code defining algebraic schemas and relations.
+- `.klib`: ahead-of-time (AOT) library objects (`main: null`) storing
+  canonical relation definitions, schemas, and local aliases.
+- `.ko`: ahead-of-time (AOT) executable containers (`KOBJ\n` magic header)
+  with entrypoint `main: "__main__"`, skipping parsing and contract
+  derivation at runtime.
 - `.kvm`: polymorphic register-IR template artifacts (`layer: "KVM-P"`)
-  carrying principal pattern graphs for instant runtime specialization
+  carrying principal schema contracts for instant runtime specialization
   (`specializeKVM`).
 
-In `k`, all relations and types are identified canonically by immutable
+In `k`, all relations and derived schemas are identified canonically by immutable
 content-addressed hashes (`@hash`). There is no global symbol namespace;
 friendly names (such as `plus`, `int`, or `5`) are local aliases stored
 in metadata. Similarly, there are no primitive numbers: numerical
-identifiers like `5` or `10` are nullary relations mapping `${} -> $bits`.
+identifiers like `5` or `10` are nullary relations mapping `{}` to `bits`.
 
 For a detailed guide to all four formats, commands, and workflows, see
 [DOCS/FILE_FORMATS.md](DOCS/FILE_FORMATS.md).
@@ -204,9 +209,9 @@ For a detailed guide to all four formats, commands, and workflows, see
 
 | Command | Purpose |
 | --- | --- |
-| `k-parse` | Convert textual k values to binary pattern+value streams |
-| `k-print` | Convert binary pattern+value streams back to textual values |
-| `k-show` | Pass a stream through while showing the decoded value/filter |
+| `k-parse` | Convert textual k values to binary schema+payload streams |
+| `k-print` | Convert binary schema+payload streams back to textual values |
+| `k-show` | Pass a stream through while showing the decoded payload and schema |
 
 **Built-in codecs**
 

package/TODO.md

@@ -17,37 +17,32 @@ This document details the issues, conceptual improvements, and completed enhance
 ## 2. Help Modal (`? Help` / `:help`) Overhaul
 
 ### Language Overview & Grammar Categorization
-- [x] **Language Overview**: Short, positive, accessible description: `k` is a concise language of types and relations (functions) over tree-like (JSON-like) documents.
-- [x] **Content-Addressed Identity**: Functions and types are identified by their canonical content hash (`@...`) derived directly from their structure; local names are just temporary aliases used for recursion and readability.
-- [x] **Three Clean Grammar Categories**:
+- [x] **Language Overview**: Short, positive, accessible description: `k` is a concise language of relations (functions) over tree-like (JSON-like) documents.
+- [x] **Content-Addressed Identity**: Relations are identified by their canonical content hash (`@...`) derived directly from their structure; local names are just temporary aliases used for recursion and readability.
+- [x] **Grammar Categories**:
    1. **Definitions (Local Aliases)**:
      - `name = relExpr;` — Relation alias (e.g. `swap = { . y x, . x y };`).
-     - `$ name = typeExpr;` &mdash; Type alias (e.g. `$ bool = < {} true, {} false >;`).
-  2. **Type Expressions (`typeExpr`)**: Schemas describing tree-like documents:
-     - `{ Type_1 label_1, ..., Type_k label_k }` &mdash; Product type of arity $k$ (labeled records, e.g. `{float64 x, string n}`; special case: `{}` is the 0-ary product).
-     - `< Type_1 tag_1, ..., Type_k tag_k >` &mdash; Union type of arity $k$ (tagged sum of variants, e.g. `<int ok, string err>`).
-     - `name` / `@hash` &mdash; Type reference.
-  3. **Relation Expressions (`relExpr`)**: Functions transforming an input document to an output document:
+   2. **Relation Expressions (`relExpr`)**: Functions transforming an input document to an output document:
      - `{ rel_1 label_1, ..., rel_k label_k }` &mdash; Product of arity $k$ (evaluates relations into record fields; special case: `{}` evaluates 0 relations, producing empty record `{}`).
      - `< rel_1, ..., rel_k >` &mdash; Union / ordered choice of arity $k$ (evaluates relations in order until one succeeds).
      - `( rel_1 ... rel_k )` &mdash; Composition of arity $k$ (sequentially composes relations; special case: `()` is the 0-ary composition denoting identity; parentheses can be omitted when non-empty: `f g`).
      - `. label` &mdash; Field projection (extracts field `label`).
      - `/ tag` &mdash; Variant branch projection (extracts payload of variant `tag`).
      - `| tag` &mdash; Variant constructor (wraps document into variant `tag`).
-     - `$ typeExpr` &mdash; Type constraint (asserts input matches schema; compile-time Type Error on mismatch).
+     - `? filterExpr` &mdash; Pattern filter (asserts input matches pattern; serves as inductive termination witness).
      - `name` / `@hash` &mdash; Relation reference.
 - [x] **Simplified Intro**:
   - Made arbitrary arity explicit across products `{...}`, unions `<...>`, and compositions `(...)`; explained `{}` and `()` as the natural 0-ary special cases; omitted the pattern/filter expressions table from the introductory reference.
 - [x] **Replaced Misleading Expressions & Snippets**:
   - Removed phantom concepts (`10` as literal, "bit-path", `{10 int x, 5 int y} plus` in default state).
-  - Added self-contained snippets (`{} | ok`, `not = < / true | false, / false | true >;`, `$ bool = < {} true, {} false >;`, `not = $ bool < / true | false, {} | true > $ bool;`, `swap = { . y x, . x y };`).
+  - Added self-contained snippets (`{} | ok`, `not = < / true | false, / false | true >;`, `bool = ?< {} true, {} false >;`, `not = bool ?X < / true | false, {} | true > ?X;`, `swap = { . y x, . x y };`).
 - [x] **Command Reference Table**:
   - Added `:time <expr>`.
   - Removed obsolete commands: `:rel <name> = expr`, `:val`, `:timing [on|off]`, `:codec define n t b`.
-  - Updated `:type <name>` to purely inspect and display type definitions (type definition is native via `$ name = typeExpr;`).
+  - Removed obsolete commands: `:type`, `:types`, `:code`, `:codes`.
   - Timing is now always enabled by default across all evaluations.
   - Updated `:input` documentation to note the interactive browser dialog.
-  - Clarified `:codes` (type aliases/hashes) and `:rels` (relation aliases).
+  - Clarified `:rels` (relation aliases).
 
 ---
 
@@ -56,15 +51,15 @@ This document details the issues, conceptual improvements, and completed enhance
 ### Concept Correction: External Format Adapters
 - [x] Reframed codecs as format adapters translating external text to/from $k$ values defined as pairs `(filter, tree)`.
 - [x] **Type-Specific Codecs**:
-  - `int`: Converts decimal integers to/from `$ int = < bits '+', bits '-' >`.
-  - `ieee`: Converts decimal floats to/from `$ float64` records (`sign`, `exponent`, `fraction`).
-  - `utf8`: Converts text to/from `$ string` (aliased to `$ utf8`), a list of Unicode scalar values (`$ unicode`) partitioned by Unicode planes.
+  - `int`: Converts decimal integers to/from `int = ?< bits '+', bits '-' >`.
+  - `ieee`: Converts decimal floats to/from `float64` records (`sign`, `exponent`, `fraction`).
+  - `utf8`: Converts text to/from `string` (aliased to `utf8`), a list of Unicode scalar values (`unicode`) partitioned by Unicode planes.
   - `unit`: Converts to/from `{}`.
 - [x] **Parameterized Codecs**:
   - `json`: JSON text is untyped; deserializing JSON requires a target $k$ type schema parameter (e.g. `:input {float64 x, string n} json`).
 - [x] **Custom Codec Studio**:
   - Updated explanation to emphasize pairs `(filter, tree)`.
-  - Fixed `yn` preset to provide self-contained type definition `$ bool = < {} true, {} false >;`.
+  - Fixed `yn` preset to provide self-contained relation definition `bool = ?< {} true, {} false >;`.
   - Fixed `blank` preset with proper Value payload formatting.
 
 ---
@@ -105,7 +100,7 @@ This document details the issues, conceptual improvements, and completed enhance
   - Verified via headless Chromium CDP automated tests that `#btn-help` is completely visible and interactable at narrow viewport widths (e.g. 600px).
 - [x] **Removed Obsolete Commands**:
   - Removed `:rel <name> = expr` and `:def` (relations are defined using native syntax `name = expr;`).
-  - Removed `:type <name> = <...>` definition syntax from `:type` (types are defined using native syntax `$ name = typeExpr;`; `:type <name>` remains for inspecting type definitions).
+  - Removed `:type`, `:types`, `:code`, `:codes` commands completely on `no-codes`.
   - Removed `:val` completely.
   - Removed `:timing [on|off]` (timing reporting is now permanently enabled by default for all evaluations; `:time <expr>` remains for explicit timing).
   - Removed `:codec define n t b` (custom codecs are created using the browser Custom Codec Studio UI or loaded from modules via `:codec load`).

package/backend-api.mjs

@@ -4,7 +4,15 @@ export { decodeWire, encodeToWire } from "./codecs/runtime/prefix-codec.mjs";
 export { exportPatternGraph, NODE_KIND } from "./codecs/runtime/codec.mjs";
 export { patternToPropertyList, propertyListToPattern } from "./codecs/runtime/pattern-json.mjs";
 export { Value, fromObject, isProduct, isVariant, isValue } from "./Value.mjs";
-export { KIR_FORMAT, KIR_VERSION, objectToKIRP, retypeObjectRelation, retypeObjectRelationForBackend } from "./kir.mjs";
+export {
+  KIR_FORMAT,
+  KIR_VERSION,
+  objectToKIRP,
+  relationPatternPropertyList,
+  retypeObjectRelation,
+  retypeObjectRelationForBackend,
+  specializeObjectRelations
+} from "./kir.mjs";
 export { compileLibrary, decodeObject, loadLibrary } from "./object.mjs";
 export { createState, evaluateInput } from "./repl.mjs";
 export { parse as parseFloat64, print as printFloat64 } from "./codecs/ieee.mjs";

package/backends/llvm/scripts/run-tests.mjs

@@ -24,6 +24,11 @@ if (process.argv.includes("-h") || process.argv.includes("--help")) {
 
 const tests = [
   ["tests/test-llvm.mjs", node, ["tests/test-llvm.mjs"]],
+  [
+    "tests/test-open-product-misalignment.mjs",
+    node,
+    ["tests/test-open-product-misalignment.mjs", "--assert"]
+  ],
   ["tests/integration.sh", path.join(root, "tests/integration.sh"), []],
   ["scripts/conformance.mjs", node, ["scripts/conformance.mjs"]]
 ];

package/backends/llvm/src/kvm2llvm.mjs

@@ -678,7 +678,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           const label = ctx.labelRef(inst.label);
           let val;
           if (edgeIndex >= 0 && ctx.runtimeMode !== "compact") {
-            val = lowerProductGetAt(ctx, input, edgeIndex, label);
+            val = lowerProductGetAt(ctx, input, edgeIndex, null);
           } else {
             val = ctx.tempName("field");
             ctx.lines.push(`  ${val} = call ptr @k_product_get_n(ptr ${input}, ptr ${label.pointer}, i64 ${label.length})`);
@@ -831,6 +831,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           }
 
           regValues.set(cleanReg(inst.dest), product);
+          if (inst.pattern) regPatterns.set(cleanReg(inst.dest), inst.pattern);
           break;
         }
         case "union": {

package/backends/llvm/src/llvm.mjs

@@ -1011,8 +1011,7 @@ export function emitLLVMModule(input, options = {}) {
 export function compileObjectToLLVM(object, options = {}) {
   const inputPattern = options.inputPattern ? readPattern(options.inputPattern) : null;
   const relation = options.relation || object.main;
-
-  let retypedKir = null;
+  let targetObject = object;
   let entryInputPattern = inputPattern;
   let outputPattern = null;
 
@@ -1020,43 +1019,37 @@ export function compileObjectToLLVM(object, options = {}) {
     const retyped = retypeObjectRelationForBackend(object, relation, inputPattern, {
       source: options.source || "<k-llvm>"
     });
-    retypedKir = retyped.kir;
+    targetObject = retyped.retypedObject;
     entryInputPattern = retyped.inputPattern;
     outputPattern = retyped.outputPattern;
-  } else {
-    retypedKir = objectToKIRP(object);
   }
 
-  let kvmArtifact = objectToKVMArtifact(object, relation, null, options);
-  let specializedKvm = kvmArtifact;
-  if (inputPattern) {
-    try {
-      specializedKvm = specializeKVM(kvmArtifact, inputPattern);
-    } catch {
-      specializedKvm = {
-        ...kvmArtifact,
-        functions: lowerKIRToKVM(retypedKir),
-        entry: relation
-      };
-    }
-  }
-
-  const entry = specializedKvm.entry || relation;
-  const functions = specializedKvm.functions;
+  const retypedKir = objectToKIRP(targetObject);
+  const functions = lowerKIRToKVM(retypedKir);
+  const entry = relation || targetObject.main || "__main__";
+
+  const specializedKvm = {
+    format: "k-vm",
+    version: 1,
+    entry,
+    functions,
+    inputPattern: entryInputPattern,
+    outputPattern
+  };
 
   const llvm = compileKVMModuleToLLVM(entry, functions, {
     ...options,
     relation,
-    inputPattern: entryInputPattern || specializedKvm.inputPattern,
-    outputPattern: outputPattern || specializedKvm.outputPattern
+    inputPattern: entryInputPattern,
+    outputPattern
   });
 
   return {
     kir: retypedKir,
     kvm: specializedKvm,
     relation,
-    inputPattern: entryInputPattern || specializedKvm.inputPattern,
-    outputPattern: outputPattern || specializedKvm.outputPattern,
+    inputPattern: entryInputPattern,
+    outputPattern,
     llvm
   };
 }

package/backends/llvm/tests/integration.sh

@@ -112,7 +112,7 @@ node --input-type=module -e "import { stdout } from 'node:process'; import { enc
   | node --input-type=module -e "import { stdin } from 'node:process'; import { decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; const chunks = []; stdin.on('data', (chunk) => chunks.push(chunk)); stdin.on('end', () => console.log(JSON.stringify(decodeWire(Buffer.concat(chunks)).pattern)));" \
   | grep -Fqx '[["open-union",[["left",1],["right",1]]],["closed-product",[]]]'
 
-node ./bin/k-llvm-build.mjs '$bits = < {} _, bits 0, bits 1 >; $int = < bits "+", bits "-" >; $int' -o "$TMP_DIR/id-int-exe"
+node ./bin/k-llvm-build.mjs '?< <bits 0, bits 1, {} _>=bits "+", bits "-">' -o "$TMP_DIR/id-int-exe"
 printf '2' \
   | node ../../codecs/int.mjs --parse \
   | "$TMP_DIR/id-int-exe" \
@@ -121,7 +121,7 @@ printf '2' \
 
 node --input-type=module -e "import assert from 'node:assert/strict'; import { spawn } from 'node:child_process'; import { encodeToWire, decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; import { parse, INT_PATTERN } from '../../codecs/int.mjs'; const input = encodeToWire(parse('2'), INT_PATTERN); const header = Buffer.alloc(4); header.writeUInt32BE(input.length); const child = spawn(process.argv[1], ['--server']); const chunks = []; const stderr = []; child.stdout.on('data', (chunk) => chunks.push(chunk)); child.stderr.on('data', (chunk) => stderr.push(chunk)); child.stdin.end(Buffer.concat([header, input])); const status = await new Promise((resolve, reject) => { child.on('error', reject); child.on('close', resolve); }); assert.equal(status, 0, Buffer.concat(stderr).toString('utf8')); const output = Buffer.concat(chunks); const length = output.readUInt32BE(0); assert.equal(output.length, 4 + length); assert.deepEqual(decodeWire(output.subarray(4)).value.toJSON(), parse('2').toJSON());" "$TMP_DIR/id-int-exe"
 
-node ./bin/k-llvm-build.mjs --lib ../../Examples/arithmetics.k --export times 's = {()x, ()y} times; s' -o "$TMP_DIR/square-exe"
+node ./bin/k-llvm-build.mjs --lib ../../Examples/arithmetics.k --export times 's = ?< <bits 0, bits 1, {} _>=bits "+", bits "-" > {()x, ()y} times; s' -o "$TMP_DIR/square-exe"
 printf '987654321' \
   | node ../../codecs/int.mjs --parse \
   | "$TMP_DIR/square-exe" \

package/backends/llvm/tests/test-llvm.mjs

@@ -239,11 +239,11 @@ assert.doesNotMatch(nestedUnionLLVM, /call void @k_product_set_at\(ptr %product\
 assert.doesNotMatch(nestedUnionLLVM, /ptr false/);
 
 const productRecurseObject = decodeObject(compileObjectBuffer(`
-  $ list = < {} nil, { {} car, list cdr } cons >;
-  foo = $list <
+  list = ?< {} nil, { {} car, list cdr } cons >;
+  foo = list <
     /nil |nil,
     /cons { .car car, .cdr foo cdr } |cons
-  > $list;
+  > list;
   foo
 `, { source: "llvm-product-recurse.k" }));
 const { llvm: productRecurseLLVM } = compileObjectToLLVM(productRecurseObject, {