@fraczak/k 7.1.0 → 8.0.0

package/Examples/djson.k

@@ -0,0 +1,323 @@
+-- Examples/djson.k: Universal dynamic JSON schema and helper relations
+-- Works with codecs/djson.mjs (k-djson) and codecs/utf8.mjs (k-utf8).
+
+---------------------------------------------------------------
+-- §1. Named Pattern Definitions & Component Schemas
+---------------------------------------------------------------
+
+bit[] = < {} 0, {} 1 >;
+
+sign[] = < {} "+", {} "-" >;
+
+exponent[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3, bit[] 4,
+  bit[] 5, bit[] 6, bit[] 7, bit[] 8, bit[] 9, bit[] 10
+};
+
+fraction[] = {
+  bit[] 0,  bit[] 1,  bit[] 2,  bit[] 3,  bit[] 4,  bit[] 5,
+  bit[] 6,  bit[] 7,  bit[] 8,  bit[] 9,  bit[] 10, bit[] 11,
+  bit[] 12, bit[] 13, bit[] 14, bit[] 15, bit[] 16, bit[] 17,
+  bit[] 18, bit[] 19, bit[] 20, bit[] 21, bit[] 22, bit[] 23,
+  bit[] 24, bit[] 25, bit[] 26, bit[] 27, bit[] 28, bit[] 29,
+  bit[] 30, bit[] 31, bit[] 32, bit[] 33, bit[] 34, bit[] 35,
+  bit[] 36, bit[] 37, bit[] 38, bit[] 39, bit[] 40, bit[] 41,
+  bit[] 42, bit[] 43, bit[] 44, bit[] 45, bit[] 46, bit[] 47,
+  bit[] 48, bit[] 49, bit[] 50, bit[] 51
+};
+
+number[] = {
+  sign[] sign,
+  exponent[] exponent,
+  fraction[] fraction
+};
+
+byte[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3,
+  bit[] 4, bit[] 5, bit[] 6, bit[] 7
+};
+
+ascii[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3,
+  bit[] 4, bit[] 5, bit[] 6
+};
+
+bmp_hi_common[] = <
+  { bit[] 0, bit[] 1, bit[] 2 } h08_0F,
+  ascii[] h10_7F,
+  ascii[] h80_CF,
+  { bit[] 0, bit[] 1, bit[] 2 } hD0_D7,
+  {} hF9,
+  { bit[] 0 } hFA_FB,
+  { bit[] 0 } hFC_FD,
+  { bit[] 0 } hFE_FF
+>;
+
+bmp_hi_private_use[] = <
+  { bit[] 0, bit[] 1, bit[] 2, bit[] 3 } hE0_EF,
+  { bit[] 0, bit[] 1, bit[] 2 } hF0_F7,
+  {} hF8
+>;
+
+plane0[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3, bit[] 4,
+  bit[] 5, bit[] 6, bit[] 7, bit[] 8, bit[] 9, bit[] 10
+};
+
+plane_02_10[] = <
+  { bit[] 0 } p02_03,
+  { bit[] 0, bit[] 1 } p04_07,
+  { bit[] 0, bit[] 1, bit[] 2 } p08_0F,
+  {} p10
+>;
+
+unicode[] = <
+  ascii[] ascii,
+  { bmp_hi_common[] hi, byte[] lo } bmp_common,
+  { bmp_hi_private_use[] hi, byte[] lo } bmp_private_use,
+  plane0[] plane0,
+  { byte[] mid, byte[] lo } supplementary_plane1,
+  { plane_02_10[] plane, byte[] mid, byte[] lo } supplementary_planes2_16
+>;
+
+string[] = < {} nil, { unicode[] car, S cdr } cons > = S;
+
+bool[] = < {} true, {} false >;
+
+list[X] = < {} nil, { X car, L cdr } cons > = L;
+
+pair[K, V] = { K key, V val };
+
+object[V] = list[pair[string[], V]];
+
+djson[] = <
+  number[] number,
+  string[] string,
+  bool[] bool,
+  {} null,
+  list[J] list,
+  object[J] object
+> = J;
+
+json? = ? djson[];
+
+bit? = ? bit[];
+string? = ? string[];
+float64? = ? number[];
+bool? = ? bool[];
+null? = ? {};
+list? = ? list[X];
+object? = ? list[pair[K, V]];
+
+---------------------------------------------------------------
+-- §2. Constructors and Projections
+---------------------------------------------------------------
+
+nil = {} | nil list?;
+cons = {.car car, .cdr cdr} | cons list?;
+car = list? /cons .car;
+cdr = list? /cons .cdr;
+
+null = {} | null json?;
+true = {} | true | bool json?;
+false = {} | false | bool json?;
+number = float64? | number json?;
+string = string? | string json?;
+bool = bool? | bool json?;
+list = list? | list json?;
+object = object? | object json?;
+
+---------------------------------------------------------------
+-- §3. String Equality (eq_string?)
+---------------------------------------------------------------
+
+eq_bit? = ?{ <{} 0, {} 1>=B x, B y }
+  < {.x /0 x, .y /0 y}, {.x /1 x, .y /1 y} > {};
+
+eq_bits1? = { {.x .0 x, .y .0 y} eq_bit? 0 } {};
+eq_bits2? = { {.x x, .y y} eq_bits1? a, {.x .1 x, .y .1 y} eq_bit? 1 } {};
+eq_bits3? = { {.x x, .y y} eq_bits2? a, {.x .2 x, .y .2 y} eq_bit? 2 } {};
+eq_bits4? = { {.x x, .y y} eq_bits3? a, {.x .3 x, .y .3 y} eq_bit? 3 } {};
+eq_bits7? = {
+  {.x x, .y y} eq_bits4? a,
+  {.x .4 x, .y .4 y} eq_bit? 4,
+  {.x .5 x, .y .5 y} eq_bit? 5,
+  {.x .6 x, .y .6 y} eq_bit? 6
+} {};
+eq_bits8? = { {.x x, .y y} eq_bits7? a, {.x .7 x, .y .7 y} eq_bit? 7 } {};
+eq_bits11? = {
+  {.x x, .y y} eq_bits8? a,
+  {.x .8 x, .y .8 y} eq_bit? 8,
+  {.x .9 x, .y .9 y} eq_bit? 9,
+  {.x .10 x, .y .10 y} eq_bit? 10
+} {};
+
+eq_bmp_common_hi? = <
+  {.x /h08_0F x, .y /h08_0F y} eq_bits3?,
+  {.x /h10_7F x, .y /h10_7F y} eq_bits7?,
+  {.x /h80_CF x, .y /h80_CF y} eq_bits7?,
+  {.x /hD0_D7 x, .y /hD0_D7 y} eq_bits3?,
+  {.x /hF9 x, .y /hF9 y} {},
+  {.x /hFA_FB x, .y /hFA_FB y} eq_bits1?,
+  {.x /hFC_FD x, .y /hFC_FD y} eq_bits1?,
+  {.x /hFE_FF x, .y /hFE_FF y} eq_bits1?
+>;
+
+eq_bmp_private_use_hi? = <
+  {.x /hE0_EF x, .y /hE0_EF y} eq_bits4?,
+  {.x /hF0_F7 x, .y /hF0_F7 y} eq_bits3?,
+  {.x /hF8 x, .y /hF8 y} {}
+>;
+
+eq_plane2_16? = <
+  {.x /p02_03 x, .y /p02_03 y} eq_bits1?,
+  {.x /p04_07 x, .y /p04_07 y} eq_bits2?,
+  {.x /p08_0F x, .y /p08_0F y} eq_bits3?,
+  {.x /p10 x, .y /p10 y} {}
+>;
+
+eq_char? = <
+  {.x /ascii x, .y /ascii y} eq_bits7?,
+  {
+    {.x /bmp_common .hi x, .y /bmp_common .hi y} eq_bmp_common_hi? hi,
+    {.x /bmp_common .lo x, .y /bmp_common .lo y} eq_bits8? lo
+  } {},
+  {
+    {
+      .x /bmp_private_use .hi x,
+      .y /bmp_private_use .hi y
+    } eq_bmp_private_use_hi? hi,
+    {.x /bmp_private_use .lo x, .y /bmp_private_use .lo y} eq_bits8? lo
+  } {},
+  {.x /plane0 x, .y /plane0 y} eq_bits11?,
+  {
+    {
+      .x /supplementary_plane1 .mid x,
+      .y /supplementary_plane1 .mid y
+    } eq_bits8? mid,
+    {
+      .x /supplementary_plane1 .lo x,
+      .y /supplementary_plane1 .lo y
+    } eq_bits8? lo
+  } {},
+  {
+    {
+      .x /supplementary_planes2_16 .plane x,
+      .y /supplementary_planes2_16 .plane y
+    } eq_plane2_16? plane,
+    {
+      .x /supplementary_planes2_16 .mid x,
+      .y /supplementary_planes2_16 .mid y
+    } eq_bits8? mid,
+    {
+      .x /supplementary_planes2_16 .lo x,
+      .y /supplementary_planes2_16 .lo y
+    } eq_bits8? lo
+  } {}
+>;
+
+_eq_string? = {.x string? x, .y string? y} <
+  {.x /nil x, .y /nil y} {},
+  {
+    {.x /cons .car x, .y /cons .car y} eq_char? if,
+    {.x /cons .cdr x, .y /cons .cdr y} then
+  } .then _eq_string?
+>;
+
+-- Identity filter on {x, y} when strings x and y are equal
+eq_string? = ?{ S x, S y } {_eq_string? if, () then} .then;
+
+---------------------------------------------------------------
+-- §4. JSON Object Helpers (dot, has_key?, keys, values, remove, put)
+---------------------------------------------------------------
+
+-- Lookup key in object entry list: {key, object} -> val
+dot = ?{ K key, O object } {.key string? key, .object object? object} <
+  {
+    {.key x, .object /cons .car .key y} eq_string? if,
+    .object /cons .car .val then
+  } .then,
+  {.key key, .object /cons .cdr object} dot
+>;
+
+-- Identity filter on {key, object} when key exists in object
+has_key? = ?{ K key, O object } {dot if, () then} .then;
+
+-- Extract list of keys from an object entry list: object -> list
+keys = object? <
+  /nil nil,
+  /cons {.car .key car, .cdr keys cdr} cons
+>;
+
+-- Extract list of values from an object entry list: object -> list
+values = object? <
+  /nil nil,
+  /cons {.car .val car, .cdr values cdr} cons
+>;
+
+-- Remove all entries matching key from object: {key, object} -> object
+remove = ?{ K key, O object } {.key string? key, .object object? object} <
+  {.object /nil if, nil then} .then,
+  {
+    {.key x, .object /cons .car .key y} eq_string? if,
+    {.key key, .object /cons .cdr object} remove then
+  } .then,
+  {
+    .object /cons .car car,
+    {.key key, .object /cons .cdr object} remove cdr
+  } cons
+>;
+
+-- Insert or replace {key, val} in object: {key, val, object} -> object
+put = ?{ K key, V val, O object } {
+  {.key string? key, .val val} car,
+  {.key key, .object object} remove cdr
+} cons;
+
+-- Lookup bits? index in cons-list: {index, list} -> value
+bits? = ?< {} _, bits? 0, bits? 1 > = bits?;
+0b = {} | _;
+0 = 0b | 0;
+1 = 0b | 1;
+
+_inv = ?{ < {} _, B 0, B 1 >=B x, B r } <
+  { .x /_ if, .r then } .then,
+  { .x /0 x, .r |0 r } _inv,
+  { .x /1 x, .r |1 r } _inv
+> bits?;
+_dec = ?{ < {} _, B 0, B 1 >=B x, B y } <
+  { .x /1 x, .y |0 r } _inv,
+  { .x /0 x, .y |1 y } _dec
+> bits?;
+_inc = ?{ < {} _, B 0, B 1 >=B x, B y } <
+  { .x /_ if, .y |1 then } .then,
+  { .x /0 x, .y |1 r } _inv,
+  { .x /1 x, .y |0 y } _inc
+> bits?;
+_trim0 = bits? < /0 _trim0, /_ 0, () >;
+dec_nat = { { () x, 0b r } _inv x, 0b y } _dec _trim0;
+inc_nat = { { () x, 0b r } _inv x, 0b y } _inc;
+
+nth = ?{ I index, L list } { .index bits? index, .list list? list } <
+  { .index /0 /_ if, .list /cons .car then } .then,
+  { .index dec_nat index, .list /cons .cdr list } nth
+>;
+
+-- Count elements in list or object: list -> bits?, object -> bits?
+_list_size = ?{
+  < {} nil, { X car, L cdr } cons >=L list,
+  < {} _, B 0, B 1 >=B acc
+} <
+  { .list /nil if, .acc then } .then,
+  { .list /cons .cdr list, .acc inc_nat acc } _list_size
+> bits?;
+list_size = { list? list, 0 acc } _list_size;
+
+_obj_size = ?{
+  < {} nil, { { K key, V val } car, O cdr } cons >=O object,
+  < {} _, B 0, B 1 >=B acc
+} <
+  { .object /nil if, .acc then } .then,
+  { .object /cons .cdr object, .acc inc_nat acc } _obj_size
+> bits?;
+obj_size = { object? object, 0 acc } _obj_size;

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,9 +247,12 @@ For a detailed guide to all four formats, commands, and workflows, see
 
 | Command | Purpose |
 | --- | --- |
-| `k-json` | Convert JSON to/from the binary stream |
-| `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 (cons-list) |
+| `k-djson-btrie` | Convert JSON to/from binary bit-trie dynamic JSON |
+| `k-djson-ptrie` | Convert JSON to/from radix trie dynamic JSON |
+| `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 |