@fraczak/k 7.2.0 → 8.1.0

package/Examples/bnat.k

@@ -1,6 +1,7 @@
 -- Standard binary encoding of natural numbers
 
-bnat? = ?< {} _, bnat? 0, bnat? 1 > = bnat?;
+bnat[] = < {} _, B 0, B 1 > = B;
+bnat? = ? bnat[];
 
 _ = {}|_;
 _1 = |1;
@@ -23,7 +24,7 @@ remove_leading_zeros = < /0 remove_leading_zeros, () >;
 reverse = {() x, _ result} _reverse;
 
 _reverse =
-  ?{ <X 0, X 1, {} _>=X x, ... }
+  ?{ bnat[] = X x, ... }
   <
     {.x/_ if, .result then} .then,
     {.x/0 x, .result _0 result} _reverse,
@@ -52,7 +53,7 @@ plus =
 
 _plus =
   -- least significant bit first addition with carry
-  ?{ <X 0, X 1, {} _>=X x, ... }
+  ?{ bnat[] = X x, ... }
   <
     {.x/_ if1, .y/_ if2, <.c/0 bnat_0, bnat_1> then} .then,
     {.x/_ if1, .c/0 if2, .y                    then} .then,
@@ -88,7 +89,7 @@ minus =
 
 _minus =
   -- least significat bit first substraction with carry
-  ?{ <X 0, X 1, {} _>=X x, <Y 0, Y 1, {} _>=Y y, ... }
+  ?{ bnat[] = X x, bnat[] = Y y, ... }
   <
     {.x   x, .y/_   y, .c/0   if} .x,
     {.x/1 x, .y/_   y, .c/1   if} .x _0,
@@ -116,10 +117,10 @@ times =
 ;
 
 _times =
-  ?{ <Y 0, Y 1, {} _>=Y y, ... }
+  ?{ bnat[] = Y y, ... }
   <
     { .y/_ if, .result then } .then,
-    { .result _0                           result, ._x _x, .y/0 y } _times,
+    { .result _0 result, ._x _x, .y/0 y } _times,
     { { ._x x, .result _0 y, c0 c } _plus  result, ._x _x, .y/1 y } _times
   >
 ;
@@ -149,7 +150,7 @@ align =
 ;
 
 _align = 
-  ?{ <X 0, X 1, {} _>=X _x, <Y 0, Y 1, {} _>=Y _y, ... }
+  ?{ bnat[] = X _x, bnat[] = Y _y, ... }
   <
     {._x/_ if1, ._y/_ if2, {.x x, .y y} then} .then,
     {._x </0, /_ _> _x, ._y </0, /_ _> _y, .x _0 x, .y _0 y} _align,
@@ -166,7 +167,7 @@ gt = {} |gt;
 
 compare = align _compare;
 _compare = 
-  ?{ <X 0, X 1, {} _>=X x, <Y 0, Y 1, {} _>=Y y, ... }
+  ?{ bnat[] = X x, bnat[] = Y y, ... }
   <
     {.x/_ if1, .y/_ if2 } eq,
     {.x/0 x, .y/0 y} _compare,
@@ -201,7 +202,11 @@ log2_floor =
 _log2_floor =
   <
     {{.step x, .x y} gt? if, .log then} .then,
-    {.x x, {.step x, bnat_0 y} gt? .x append_0 step, .log inc log} _log2_floor
+    {
+      .x x,
+      {.step x, bnat_0 y} gt? .x append_0 step,
+      .log inc log
+    } _log2_floor
   >
 ;
 
@@ -260,7 +265,11 @@ pow =
   <
     .exponent zero? bnat_1,
     {.base base, .exponent half half}
-    {.base base, .half.rem extra, {.base base, .half.div exponent} pow {()x,()y} times pow}
+    {
+      .base base,
+      .half.rem extra,
+      {.base base, .half.div exponent} pow {()x, ()y} times pow
+    }
     <
       {.extra zero? if, .pow then} .then,
       {.base x, .pow y} times
@@ -281,7 +290,8 @@ _sqrt =
     { () aux, {.input.x x, .middle y} div .div middle }
     { 
       .aux.input.x x, 
-      { .aux.middle x, .middle y } < gt?, {.x y, .y x} > {.y min, .x max} range
+      { .aux.middle x, .middle y }
+        < gt?, {.x y, .y x} > {.y min, .x max} range
     } _sqrt
   >
 ;

package/Examples/buda.k

@@ -1,44 +1,61 @@
-// we will use arithmetics.k
+-- Examples/buda.k: Relational list algorithms using named patterns
+-- Uses arbitrary-precision integers from Examples/arithmetics.k.
 
-nths = ?{$int n, LIST list} 
+bits[] = < {} _, B 0, B 1 > = B;
+int[] = < bits[] "+", bits[] "-" >;
+
+list[X] = < {} nil, { X car, Y cdr } cons > = Y;
+list? = ? list[X];
+
+nil = {} | nil list?;
+cons = { .car car, .cdr cdr } | cons list?;
+car = list? /cons .car;
+cdr = list? /cons .cdr;
+
+nths = ?{ int[] n, list[X] list } 
   < 
-    {.n pos? dec n, .list cdr list } nths,
-    {.n zero_int? if, .list list? car then} .then
+    { .n pos? dec n, .list cdr list } nths,
+    { .n zero_int? if, .list car then } .then
   >;
 
-reverse = ? LIST  list?
-  {nil ? LIST reversed, () list } _reverse;
+reverse = ? list[X]
+  { nil reversed, () list } _reverse;
   
-_reverse = ?{ LIST reversed, LIST list} 
+_reverse = ?{ list[X] reversed, list[X] list } 
   <   
-    {{.list car car, .reversed cdr} cons reversed, .list cdr list } _reverse,
+    {
+      { .list car car, .reversed cdr } cons reversed,
+      .list cdr list
+    } _reverse,
     .reversed
   >
 ;
 
-split = ? LIST 
-  { nil ? LIST odd, nil ? LIST even, reverse list } _split
+split = ? list[X]
+  { nil odd, nil even, reverse list } _split
 ;
 
-_split = ? { LIST odd, LIST even, LIST list }
+_split = ?{ list[X] odd, list[X] even, list[X] list }
   < 
     { 
-        {.list car car, .odd cdr} cons odd,
-        .even even,
-        .list cdr list
+      { .list car car, .odd cdr } cons odd,
+      .even even,
+      .list cdr list
     } split_,
 
-    {.odd odd, .even even}
+    { .odd odd, .even even }
   >
 ;
 
-split_ = ? { LIST odd, LIST even, LIST list }
+split_ = ?{ list[X] odd, list[X] even, list[X] list }
   < 
     { 
-        .odd odd,
-        {.list car car, .even cdr} cons even,
-        .list cdr list
+      .odd odd,
+      { .list car car, .even cdr } cons even,
+      .list cdr list
     } _split,
-    {.odd odd, .even even}
+    { .odd odd, .even even }
   >
 ;
+
+()

package/Examples/byte.k

@@ -11,7 +11,9 @@ map = <
   _
 > | ascii;
 
-filter = ?< {} nil, { (...) car, S cdr } cons > = S <
+list[X] = < {} nil, { X car, Y cdr } cons > = Y;
+
+filter = ? list[(...)] <
   /cons {.car map car, .cdr filter cdr} | cons,
   () 
 >;

package/Examples/code.k

@@ -1,44 +1,43 @@
-$ code = < fields product, fields union, chars ref >;
-$ fields = < {} nil, { chars car, fields cdr } cons >;
-$ chars = < 
-    chars" ", chars"!", chars'"', chars"#", chars"$", chars"%", chars"&", chars"'", 
-    chars"(", chars")", chars"*", chars"+", chars",", chars"-", chars".", chars"/", 
-    chars"0", chars"1", chars"2", chars"3", chars"4", chars"5", chars"6", chars"7", 
-    chars"8", chars"9", chars":", chars";", chars"<", chars"=", chars">", chars"?", 
-    chars"@", chars"A", chars"B", chars"C", chars"D", chars"E", chars"F", chars"G", 
-    chars"H", chars"I", chars"J", chars"K", chars"L", chars"M", chars"N", chars"O", 
-    chars"P", chars"Q", chars"R", chars"S", chars"T", chars"U", chars"V", chars"W", 
-    chars"X", chars"Y", chars"Z", chars"[", chars"\\", chars"]", chars"^", chars"_", 
-    chars"`", chars"a", chars"b", chars"c", chars"d", chars"e", chars"f", chars"g", 
-    chars"h", chars"i", chars"j", chars"k", chars"l", chars"m", chars"n", chars"o", 
-    chars"p", chars"q", chars"r", chars"s", chars"t", chars"u", chars"v", chars"w", 
-    chars"x", chars"y", chars"z", chars"{", chars"|", chars"}", chars"~",
-    {} end
- >;
- 
- $ char = <
-    {}" ", {}"!", {}'"', {}"#", {}"$", {}"%", {}"&", {}"'", 
-    {}"(", {}")", {}"*", {}"+", {}",", {}"-", {}".", {}"/", 
-    {}"0", {}"1", {}"2", {}"3", {}"4", {}"5", {}"6", {}"7", 
-    {}"8", {}"9", {}":", {}";", {}"<", {}"=", {}">", {}"?", 
-    {}"@", {}"A", {}"B", {}"C", {}"D", {}"E", {}"F", {}"G", 
-    {}"H", {}"I", {}"J", {}"K", {}"L", {}"M", {}"N", {}"O", 
-    {}"P", {}"Q", {}"R", {}"S", {}"T", {}"U", {}"V", {}"W", 
-    {}"X", {}"Y", {}"Z", {}"[", {}"\\", {}"]", {}"^", {}"_", 
-    {}"`", {}"a", {}"b", {}"c", {}"d", {}"e", {}"f", {}"g", 
-    {}"h", {}"i", {}"j", {}"k", {}"l", {}"m", {}"n", {}"o", 
-    {}"p", {}"q", {}"r", {}"s", {}"t", {}"u", {}"v", {}"w", 
-    {}"x", {}"y", {}"z", {}"{", {}"|", {}"}", {}"~"
- >;
+-- Examples/code.k: Pattern representation and encoding
 
+chars[] = < 
+  C " ", C "!", C '"', C "#", C "$", C "%", C "&", C "'", 
+  C "(", C ")", C "*", C "+", C ",", C "-", C ".", C "/", 
+  C "0", C "1", C "2", C "3", C "4", C "5", C "6", C "7", 
+  C "8", C "9", C ":", C ";", C "<", C "=", C ">", C "?", 
+  C "@", C "A", C "B", C "C", C "D", C "E", C "F", C "G", 
+  C "H", C "I", C "J", C "K", C "L", C "M", C "N", C "O", 
+  C "P", C "Q", C "R", C "S", C "T", C "U", C "V", C "W", 
+  C "X", C "Y", C "Z", C "[", C "\\", C "]", C "^", C "_", 
+  C "`", C "a", C "b", C "c", C "d", C "e", C "f", C "g", 
+  C "h", C "i", C "j", C "k", C "l", C "m", C "n", C "o", 
+  C "p", C "q", C "r", C "s", C "t", C "u", C "v", C "w", 
+  C "x", C "y", C "z", C "{", C "|", C "}", C "~",
+  {} end
+> = C;
 
-nil = {}|nil;
-_ = {}|end $chars;
+char[] = <
+  {} " ", {} "!", {} '"', {} "#", {} "$", {} "%", {} "&", {} "'", 
+  {} "(", {} ")", {} "*", {} "+", {} ",", {} "-", {} ".", {} "/", 
+  {} "0", {} "1", {} "2", {} "3", {} "4", {} "5", {} "6", {} "7", 
+  {} "8", {} "9", {} ":", {} ";", {} "<", {} "=", {} ">", {} "?", 
+  {} "@", {} "A", {} "B", {} "C", {} "D", {} "E", {} "F", {} "G", 
+  {} "H", {} "I", {} "J", {} "K", {} "L", {} "M", {} "N", {} "O", 
+  {} "P", {} "Q", {} "R", {} "S", {} "T", {} "U", {} "V", {} "W", 
+  {} "X", {} "Y", {} "Z", {} "[", {} "\\", {} "]", {} "^", {} "_", 
+  {} "`", {} "a", {} "b", {} "c", {} "d", {} "e", {} "f", {} "g", 
+  {} "h", {} "i", {} "j", {} "k", {} "l", {} "m", {} "n", {} "o", 
+  {} "p", {} "q", {} "r", {} "s", {} "t", {} "u", {} "v", {} "w", 
+  {} "x", {} "y", {} "z", {} "{", {} "|", {} "}", {} "~"
+>;
 
-KL = _|L|K $chars;
- 
-bool =  
-    { KL car, { KL car, nil cdr } | cons cdr } | cons | union
-$code;
+fields[] = < {} nil, { chars[] car, F cdr } cons > = F;
 
+code[] = < fields[] product, fields[] union, chars[] ref >;
+
+nil = {} | nil;
+_ = ({} | end) ? chars[];
+KL = (_ | L | K) ? chars[];
+
+bool = { KL car, { KL car, nil cdr } | cons cdr } | cons | union ? code[];
 bool