@fraczak/k 7.2.0 → 8.1.0

package/Examples/esc.k

@@ -1,4 +1,4 @@
-$ utf8 = <{} '
+utf8[] = <{} '
 \u2601\u2600\u2602
 ',
 {} '✅',

package/Examples/karatsuba-mult.k

@@ -5,19 +5,21 @@
 yes = {} | yes;
 no = {} | no;
 
-bits? = ?< {} _, bits? 0, bits? 1 > = bits?;
+bits[] = < {} _, B 0, B 1 > = B;
+bits? = ? bits[];
 0b = {} | _;
 0 = 0b |0;
 1 = 0b |1;
 
-unat? = ?< {} _, unat? 1 > = unat?;
+unat[] = < {} _, U 1 > = U;
+unat? = ? unat[];
 0u = {} | _;
 
 empty = < /_ yes, no >;
 empty? = {empty /yes if, () then} .then;
 
 inv = {()x, 0b r} _inv;
-_inv = ?{ <X 0, X 1, {} _>=X x, ... }
+_inv = ?{ bits[] = X x, ... }
 <
   {.x empty? if, .r then} .then,
   <
@@ -27,7 +29,7 @@ _inv = ?{ <X 0, X 1, {} _>=X x, ... }
 >;
 
 concat = {.x inv x, .y y} concat_;
-concat_ = ?{ <X 0, X 1, {} _>=X x, ... }
+concat_ = ?{ bits[] = X x, ... }
 <
   {.x empty? if, .y then} .then,
   <
@@ -50,7 +52,7 @@ c0 = {} | 0;
 c1 = {} | 1;
 
 _plus = {.x x, .y y, .c c, 0b r} _plus_;
-_plus_ = ?{ <X 0, X 1, {} _>=X x, ... }
+_plus_ = ?{ bits[] = 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,
@@ -70,7 +72,7 @@ _plus_ = ?{ <X 0, X 1, {} _>=X x, ... }
 >;
 
 _minus = {.x x, .y y, .c c, 0b r} _minus_;
-_minus_ = ?{ <X 0, X 1, {} _>=X x, ... }
+_minus_ = ?{ bits[] = X x, ... }
 <
   {.y empty? if, .c/0 and, {.r x, .x r} _inv then} .then,
   <
@@ -90,7 +92,7 @@ _minus_ = ?{ <X 0, X 1, {} _>=X x, ... }
 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 = ?{ <Y 0, Y 1, {} _>=Y y, ... }
+_times = ?{ bits[] = Y y, ... }
 <
   {.y empty? if, .result then} .then,
   <
@@ -100,19 +102,20 @@ _times = ?{ <Y 0, Y 1, {} _>=Y y, ... }
 >;
 times_bits = {0 result, .x inv _x, .y y} _times inv nat;
 
-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;
+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[];
 
 _peel2 = < </0,/1> </0,/1>, </0,/1>, () >;
-_half_unat = ?{ <X 0, X 1, {} _>=X x, ... }
+_half_unat = ?{ bits[] = 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 = ?{ <X 0, X 1, {} _>=X x_rev, <M 1, {} _>=M m, ... }
+_split_rev_u = ?{ bits[] = X x_rev, unat[] = 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,
@@ -155,7 +158,7 @@ shift2_bits_u =
   {.val x, .m unat_to_double_zeros y} concat
 >;
 
-_karatsuba = ?{ <X 0, X 1, {} _>=X x, <Y 0, Y 1, {} _>=Y y }
+_karatsuba = ?{ bits[] = X x, bits[] = 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}

package/Examples/list.k

@@ -1,7 +1,11 @@
-list? = ?< {} nil, {X car, Y cdr} cons > = Y;
-nil = {} |nil list?;
-singleton = {() car, nil cdr} | cons list?;
-cons = {.car car, .cdr cdr} | cons list?;
+-- Examples/list.k: Generic linked list patterns and relations
+
+list[X] = < {} nil, { X car, Y cdr } cons > = Y;
+list? = ? list[X];
+
+nil = {} | nil list?;
+singleton = { () car, nil cdr } | cons list?;
+cons = { .car car, .cdr cdr } | cons list?;
 nil? = list? /nil nil;
 car = list? /cons .car;
 cdr = list? /cons .cdr;

package/Examples/nat.k

@@ -1,11 +1,17 @@
-0 = {} | 0 ;
-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
-> ;
-
-succ {()x,()y} add
+-- Examples/nat.k: Peano natural numbers arithmetic
+
+0 = {} | 0;
+0? = { /0 if, () then } .then;
+succ = | +1;
+pred = / +1;
+
+nat[] = < {} 0, N +1 > = N;
+nat? = ? nat[];
+
+add = ?{ nat[] = N x, ... } = X <{.x pred x, .y succ y} ?X add, .y>;
+mult = ?{ nat[] = M x, ... } <
+  {{.x pred x, .y y} mult x, .y y} add,
+  0
+>;
+
+succ {()x, ()y} add

package/Examples/poly.k

@@ -2,7 +2,8 @@
 -- Uses arbitrary-precision integers from Examples/arithmetics.k.
 
 -- List constructors and destructors
-list? = ?< {} nil, {X car, Y cdr} cons > = Y;
+list[X] = < {} nil, { X car, Y cdr } cons > = Y;
+list? = ? list[X];
 nil = {} | nil list?;
 singleton = {() car, nil cdr} | cons list?;
 cons = {.car car, .cdr cdr} | cons list?;
@@ -95,8 +96,15 @@ gt? =
 split = {() xs, nil first, nil second} _split;
 _split = <
   {.xs /nil if, {.first first, .second second} then} .then,
-  {.xs cdr /nil if, {{.xs car car, .first cdr} cons first, .second second} then} .then,
-  {.xs cdr cdr xs, {.xs car car, .first cdr} cons first, {.xs cdr car car, .second cdr} cons second} _split
+  {
+    .xs cdr /nil if,
+    {{.xs car car, .first cdr} cons first, .second second} then
+  } .then,
+  {
+    .xs cdr cdr xs,
+    {.xs car car, .first cdr} cons first,
+    {.xs cdr car car, .second cdr} cons second
+  } _split
 >;
 
 -- Merge two sorted lists: {xs, ys} -> list

package/Examples/vhdl_to_k.k

@@ -1,50 +1,62 @@
 -- VHDL to K Translation Patterns
 
 -- VHDL: signal a : std_logic;
--- K:    $ bit = <{} 0, {} 1>;
+-- K:    bit[] = < {} 0, {} 1 >;
+bit[] = < {} 0, {} 1 >;
 
 -- VHDL: signal bus : std_logic_vector(7 downto 0);
--- K:    $ byte = {bit 0, bit 1, bit 2, bit 3, bit 4, bit 5, bit 6, bit 7};
+-- K:    byte[] = {
+--         bit[] 0, bit[] 1, bit[] 2, bit[] 3,
+--         bit[] 4, bit[] 5, bit[] 6, bit[] 7
+--       };
+byte[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3,
+  bit[] 4, bit[] 5, bit[] 6, bit[] 7
+};
+
+nibble[] = { bit[] 0, bit[] 1, bit[] 2, bit[] 3 };
 
--- VHDL: entity adder is port(a,b: in std_logic; sum: out std_logic); end;
--- K:    adder = ${bit a, bit b} {.a a_out, .b b_out, xor_gate sum_out};
+0 = {} | 0;
+1 = {} | 1;
 
--- VHDL: process(clk) begin if rising_edge(clk) then q <= d; end if; end;
--- K:    dff = $bit .;  -- Identity (register holds value)
+-- VHDL: y <= not a;
+not_bit = < /0 1, /1 0 >;
 
 -- VHDL: y <= a and b;
--- K:    and_gate = ${bit a, bit b} <{.a.1 1, .b.1 1, 1}, 0>;
+and_bit = < .x/0 0, .y/0 0, 1 >;
 
--- VHDL: y <= a or b;  
--- K:    or_gate = ${bit a, bit b} <{.a.0 0, .b.0 0, 0}, 1>;
+-- VHDL: y <= a or b;
+or_bit = < .x/1 1, .y/1 1, 0 >;
 
--- VHDL: y <= not a;
--- K:    not_gate = $bit <{.0 0, 1}, {.1 1, 0}>;
+-- VHDL: y <= a xor b;
+xor_bit = < {.x/0 if, .y then} .then, .y not_bit >;
+xor_abc = {{.a x, .b y} xor_bit x, .c y} xor_bit;
 
--- VHDL: with sel select y <= a when "00", b when "01", c when others;
--- K:    mux = ${bit sel0, bit sel1, bit a, bit b, bit c} <
---             {.sel0.0 0, .sel1.0 0, .a},
---             {.sel0.1 1, .sel1.0 0, .b}, 
---             .c>;
+-- VHDL: Full adder component
+full_adder = ?{ bit[] a, bit[] b, bit[] c_in } {
+  {.a a, .b b, .c_in c} xor_abc sum,
+  {
+    {.a x, .b y} and_bit x,
+    {{.a x, .b y} xor_bit x, .c_in y} and_bit y
+  } or_bit carry
+};
 
 -- VHDL: architecture of 4-bit adder
-four_bit_adder = ${
-  {bit 0, bit 1, bit 2, bit 3} a,
-  {bit 0, bit 1, bit 2, bit 3} b
+four_bit_adder = ?{ nibble[] a, nibble[] b } {
+  .a a, .b b,
+  {.a.0 a, .b.0 b, 0 c_in} full_adder fa0
+} {
+  .a a, .b b, .fa0 fa0,
+  {.a.1 a, .b.1 b, .fa0.carry c_in} full_adder fa1
+} {
+  .a a, .b b, .fa0 fa0, .fa1 fa1,
+  {.a.2 a, .b.2 b, .fa1.carry c_in} full_adder fa2
+} {
+  .fa0 fa0, .fa1 fa1, .fa2 fa2,
+  {.a.3 a, .b.3 b, .fa2.carry c_in} full_adder fa3
 } {
-  {.a.0 a0, .b.0 b0} full_adder fa0,
-  {.a.1 a1, .b.1 b1, .fa0.carry c_in} full_adder fa1,
-  {.a.2 a2, .b.2 b2, .fa1.carry c_in} full_adder fa2,
-  {.a.3 a3, .b.3 b3, .fa2.carry c_in} full_adder fa3,
   {.fa0.sum 0, .fa1.sum 1, .fa2.sum 2, .fa3.sum 3} sum,
   .fa3.carry overflow
 };
 
--- VHDL: Full adder component
-full_adder = ${bit a, bit b, bit c_in} {
-  {.a a_val, .b b_val} xor_gate ab_xor,
-  {.ab_xor xor_val, .c_in c_val} xor_gate sum,
-  {.a a_val, .b b_val} and_gate ab_and,
-  {.ab_xor xor_val, .c_in c_val} and_gate xor_cin_and,
-  {.ab_and and1, .xor_cin_and and2} or_gate carry
-};
+()

package/README.md

@@ -45,18 +45,19 @@ 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, N +1 > = N;
 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'
+add = ?{ nat[] = N x, ... } <
+  { .x dec x, .y inc y } add,    # defined if 'x > 0'
+  .y                             # else, return '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`. The inductive filter `?{ < {} 0, N +1 > = N x, ... }`
+returns `y`. The inductive filter `?{ nat[] = N x, ... }`
 explicitly witnesses that recursive calls shrink `x`.
 
 In the REPL:
@@ -122,19 +123,41 @@ Every installed command supports `-h` and `--help`.
 
 ## What k Gives You
 
-**Algebraic data shapes**
+**Algebraic data shapes and named patterns**
 
-All data structures in k are built from products and tagged unions (variants).
-Relations and pattern filters describe their domains:
+All data structures in k are built from products and tagged unions
+(variants). Reusable named patterns describe structural type schemas
+using square brackets `name[...]`:
 
 ```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 > = bits?;
+bit[]  = < {} 0, {} 1 >;
+bits[] = < {} _, B 0, B 1 > = B;
+byte[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3,
+  bit[] 4, bit[] 5, bit[] 6, bit[] 7
+};
+
+-- Parameterized type templates:
+list[X] = < {} nil, { X car, Y cdr } cons > = Y;
+pair[A, B] = { A first, B second };
 ```
 
-There are no built-in primitive values. The empty product `{}` is the
-only leaf in a non-recursive definition.
+Callers instantiate patterns using `? name[...]` as standalone filters
+or inside relation parameter guards (`?{ nat[] = N x, ... }`). There are
+no built-in primitive values: the empty product `{}` is the only leaf
+in a non-recursive definition.
+
+**The four-bracket architecture**
+
+k uses an orthogonal four-bracket convention with non-overlapping
+semantic domains:
+
+| Brackets | Domain | Purpose & Concrete Example |
+| :--- | :--- | :--- |
+| `{ ... }` | Products | Record construction: `{ f a, g b }`, `{}` |
+| `< ... >` | Unions | Variant choice: `< f, g >`, `<>` |
+| `( ... )` | Relations | Composition & identity: `(f g)`, `()` |
+| `[ ... ]` | Patterns | Reusable templates: `list[X]`, `bit[]` |
 
 **Composable partial functions**
 
@@ -149,6 +172,7 @@ Core expressions are deliberately small:
 | `<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 |
+| `name[...]` | instantiate named pattern template |
 | `()` | identity |
 | `<>` | always undefined |
 | `{}` | constant empty product |
@@ -223,10 +247,10 @@ For a detailed guide to all four formats, commands, and workflows, see
 
 | Command | Purpose |
 | --- | --- |
-| `k-json` | Convert JSON to/from the binary stream (schema-specializing) |
-| `k-djson` | Convert JSON to/from a universal dynamic JSON singleton pattern |
-| `k-int` | Convert decimal integers to/from the binary stream |
-| `k-ieee` | Convert float literals to/from the binary stream |
+| `k-json` | Convert JSON to/from binary stream (specializing) |
+| `k-djson` | Convert JSON to/from dynamic JSON (binary bit-trie) |
+| `k-int` | Convert decimal integers to/from binary stream |
+| `k-ieee` | Convert float literals to/from binary stream |
 | `k-unit` | Produce or validate the unit value |
 | `k-utf8` / `k-utf16` | Convert text to/from k string streams |
 

package/browser/repl-browser.mjs

@@ -632,6 +632,8 @@ function renderCodecsModal() {
       targetDesc = "{}";
     } else if (entry.name === "json.mjs") {
       targetDesc = "Self-describing JSON";
+    } else if (entry.name === "djson.mjs") {
+      targetDesc = "$ json (binary bit-trie)";
     } else if (Array.isArray(entry.patterns) && entry.patterns.length > 0) {
       targetDesc = `Pattern Family (${entry.patterns.length})`;
     } else if (entry.pattern) {

package/browser/tree-view.mjs

@@ -455,7 +455,7 @@ export function createOutputEntryElement({
   modeGroup.appendChild(rawBtn);
   toolbar.appendChild(modeGroup);
 
-  // Tree Action buttons group (Expand / Collapse / Copy)
+  // Tree Action buttons group (Expand / Collapse)
   const actionGroup = document.createElement("div");
   actionGroup.className = "k-action-group";
 
@@ -471,23 +471,8 @@ export function createOutputEntryElement({
   collapseAllBtn.innerHTML = `⊟ Collapse`;
   collapseAllBtn.title = "Reset trees to top 3 levels";
 
-  const copyBtn = document.createElement("button");
-  copyBtn.type = "button";
-  copyBtn.className = "k-btn-action";
-  copyBtn.innerHTML = `📋 Copy`;
-  copyBtn.title = "Copy raw output to clipboard";
-  copyBtn.onclick = (e) => {
-    e.stopPropagation();
-    navigator.clipboard.writeText(rawText);
-    copyBtn.innerHTML = `✓ Copied`;
-    setTimeout(() => {
-      copyBtn.innerHTML = `📋 Copy`;
-    }, 1500);
-  };
-
   actionGroup.appendChild(expandAllBtn);
   actionGroup.appendChild(collapseAllBtn);
-  actionGroup.appendChild(copyBtn);
   toolbar.appendChild(actionGroup);
 
   container.appendChild(toolbar);
@@ -512,6 +497,23 @@ export function createOutputEntryElement({
     `<span class="k-tree-arrow">▶</span> ` +
     `<span class="k-section-title">🌲 Value</span> ` +
     `<span class="k-section-preview">${valEscaped}</span>`;
+
+  const copyValBtn = document.createElement("button");
+  copyValBtn.type = "button";
+  copyValBtn.className = "k-btn-action k-btn-copy k-btn-copy-value";
+  copyValBtn.innerHTML = `📋 Copy`;
+  copyValBtn.title = "Copy value definition to clipboard";
+  copyValBtn.onclick = (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    const valStr = valueToK(value);
+    navigator.clipboard.writeText(valStr);
+    copyValBtn.innerHTML = `✓ Copied`;
+    setTimeout(() => {
+      copyValBtn.innerHTML = `📋 Copy`;
+    }, 1500);
+  };
+  valSummary.appendChild(copyValBtn);
   valSection.appendChild(valSummary);
 
   const valBody = document.createElement("div");
@@ -538,6 +540,23 @@ export function createOutputEntryElement({
       `<span class="k-tree-arrow">▶</span> ` +
       `<span class="k-section-title">🌿 Pattern</span> ` +
       `<span class="k-section-preview">?${patEscaped}</span>`;
+
+    const copyPatBtn = document.createElement("button");
+    copyPatBtn.type = "button";
+    copyPatBtn.className = "k-btn-action k-btn-copy k-btn-copy-pattern";
+    copyPatBtn.innerHTML = `📋 Copy`;
+    copyPatBtn.title = "Copy pattern definition to clipboard";
+    copyPatBtn.onclick = (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      const patStr = `?${propertyListToFilter(value.pattern, "X")}`;
+      navigator.clipboard.writeText(patStr);
+      copyPatBtn.innerHTML = `✓ Copied`;
+      setTimeout(() => {
+        copyPatBtn.innerHTML = `📋 Copy`;
+      }, 1500);
+    };
+    patSummary.appendChild(copyPatBtn);
     patSection.appendChild(patSummary);
 
     patBody = document.createElement("div");