@fraczak/k 6.3.3 → 6.5.0

package/Examples/arithmetics.k

@@ -15,10 +15,10 @@ cdr = list? /cons .cdr;
 $ bits = < {} _, bits 0, bits 1 >;
 
 0b = {} | _;
-1_ = | 1;
-0_ = | 0;
+-- |1 = | 1;
+-- |0  = | 0;
 
-0 = 0b 0_;
+0 = 0b |0;
 succ = {inv x, 0b y} _inc;
 1 = 0 succ;
 2 = 1 succ;
@@ -39,22 +39,33 @@ empty? = {empty /yes if, () then} .then;
 concat = ${bits x, bits y} {.x inv x, .y y} concat_; 
 concat_ = ${bits x, bits y} 
   < 
-    {.x /0 x, .y 0_ y} concat_, 
-    {.x /1 x, .y 1_ y} concat_, 
-    .y 
+    {.x empty? if, .y then} .then,
+    < 
+      {.x /0 x, .y |0 y}, 
+      {.x /1 x, .y |1 y}
+    > concat_ 
   >;
 inv = {()x, 0b r} _inv; 
-_inv = ${bits x, bits r} < {.x /0 x, .r 0_ r} _inv, {.x /1 x, .r 1_ r} _inv, .r >;
+_inv = ${bits x, bits r} 
+  < 
+    {.x empty? if, .r then} .then,
+    < 
+      {.x /0 x, .r |0 r}, 
+      {.x /1 x, .r |1 r}
+   > _inv
+  >;
 
 inOrder = ${bits x, bits y} {.x inv x, .y inv y, yes inOrder} inOrder_;
 inOrder_ = ${bits x, bits y, yes_no inOrder} 
   < 
-    {.x /0 x, .y /0 y, .inOrder inOrder} inOrder_, 
-    {.x /1 x, .y /1 y, .inOrder inOrder} inOrder_,
-    {.x /0 x, .y /1 y, .inOrder inOrder} inOrder_, 
-    {.x /1 y, .y /0 x, .inOrder swap_yes_no inOrder} inOrder_, 
-    {.x </0,/1> if, .inOrder swap_yes_no then} .then, 
-    .inOrder
+    {.x </0,/1> if1, .y /_ if2, .inOrder swap_yes_no then} .then,
+    {.x /_ if, .inOrder then} .then,
+    < 
+      {.x /0 x, .y /0 y, .inOrder inOrder}, 
+      {.x /1 x, .y /1 y, .inOrder inOrder},
+      {.x /0 x, .y /1 y, .inOrder inOrder}, 
+      {.x /1 y, .y /0 x, .inOrder swap_yes_no inOrder}
+    > inOrder_
   >;
 
 GT = {inOrder /no if, () then} . then;
@@ -63,18 +74,21 @@ EQ = GT {.x y, .y x} GT;
 
 toBitList = {inv x, nil r} _toBitList; 
 _toBitList = < 
-  {.x empty? if, .r then }.then, 
-  {.x /0 x, {0 car, .r cdr} cons r} _toBitList, 
-  {.x /1 x, {1 car, .r cdr} cons r} _toBitList 
+  {.x empty? if, .r then}.then, 
+  <
+    {.x /0 x, {0 car, .r cdr} cons r}, 
+    {.x /1 x, {1 car, .r cdr} cons r}
+  > _toBitList 
 >;
-fromBitList =
-< 
-  cdr <
-    {car /0 if, cdr fromBitList 0_ then} .then, 
-    {car /1 if, cdr fromBitList 1_ then} .then
-  >, 
-  0b
-> $bits;
+fromBitList = {() l, 0b r} _fromBitList inv $bits;
+_fromBitList =
+  <
+    {.l nil? if, .r then} .then,
+    <
+      {.l car /0 if, {.l cdr l, .r |0 r} then} .then,
+      {.l car /1 if, {.l cdr l, .r |1 r} then} .then
+    > _fromBitList
+  >;
 
 --------------------------------------
 $ int = < bits '+', bits '-' >;
@@ -93,26 +107,26 @@ zero_int? = $int {/'+' /0 empty? if, () then} .then;
 minus_one? = $int {/'-' /1 empty? if, () then} .then;
 
 inc = $int <
-  /'+' {inv x, 0b y} _inc |'+',
+  /'+' {inv x, 0b y} _inc nat |'+',
   minus_one? 0 int,
-  /'-' {inv x, 0b y} _dec |'-'
->;
+  /'-' {inv x, 0b y} _dec nat |'-'
+> $int;
 
 _inc = ${bits x, bits y} <
-    {.x /0 x, .y 1_ y} concat_, 
-    {.x /1 x, .y 0_ y} _inc,
-    .y 1_
+    {.x empty? if, .y |1 then} .then,
+    {.x /0 x, .y |1 y} concat_, 
+    {.x /1 x, .y |0  y} _inc
 >; 
 
 dec = $int <
   zero_int? 1 |'-',
-  /'+' {inv x, 0b y} _dec |'+',
-  /'-' {inv x, 0b y} _inc |'-'
+  /'+' {inv x, 0b y} _dec nat |'+',
+  /'-' {inv x, 0b y} _inc nat |'-'
 > $int;
 
 _dec = ?{X x, X y, ...} <
-    {.x /1 x, .y 0_ y} concat_, 
-    {.x /0 x, .y 1_ y} _dec
+    {.x /1 x, .y |0  y} concat_, 
+    {.x /0 x, .y |1 y} _dec
 > ?X;
 
 $carry = <{} 0, {} 1>;
@@ -139,45 +153,54 @@ swap_sign = <
 minus = ${int x, int y}
   {.x x, .y swap_sign y} plus;
 
-_plus =
+_plus = {.x x, .y y, .c c, 0b r} _plus_;
+
+_plus_ =
   -- least significant bit first addition with carry
-  ${bits x, bits y, carry c}
+  ${bits x, bits y, carry c, bits r}
   <
-    {.x empty? if, .y empty? and, <.c/0 0, 1> then} .then,
-    {.x empty? if, .c/0 and, .y then} .then,
+    {.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,
+    {.x empty? if, .c/0 and, {.r x, .y r} _inv then} .then,
 
-    {.x y, .y empty? x, .c c} _plus,
-    {<.c/0 0, 1> x, 
-              .y y, .x empty? c0 c} _plus,
+    <
+      {.x y, .y empty? x, .c c, .r r},
+      {<.c/0 0, 1> x, .y y, .x empty? c0 c, .r r},
 
-    {.x /0 x, .y /0 y, .c/0 c0 c} _plus 0_,
-    {.x /0 x, .y /0 y, .c/1 c0 c} _plus 1_,
+      {.x /0 x, .y /0 y, .c/0 c0 c, .r |0 r},
+      {.x /0 x, .y /0 y, .c/1 c0 c, .r |1 r},
 
-    {.x /0 x, .y /1 y, .c/0 c0 c} _plus 1_,
-    {.x /0 x, .y /1 y, .c/1 c1 c} _plus 0_,
-    {.x /1 x, .y /0 y, .c/0 c0 c} _plus 1_,
-    {.x /1 x, .y /0 y, .c/1 c1 c} _plus 0_,
+      {.x /0 x, .y /1 y, .c/0 c0 c, .r |1 r},
+      {.x /0 x, .y /1 y, .c/1 c1 c, .r |0 r},
+      {.x /1 x, .y /0 y, .c/0 c0 c, .r |1 r},
+      {.x /1 x, .y /0 y, .c/1 c1 c, .r |0 r},
 
-    {.x /1 x, .y /1 y, .c/0 c1 c} _plus 0_,
-    {.x /1 x, .y /1 y, .c/1 c1 c} _plus 1_
+      {.x /1 x, .y /1 y, .c/0 c1 c, .r |0 r},
+      {.x /1 x, .y /1 y, .c/1 c1 c, .r |1 r}
+    > _plus_
   >
 ;
 
-_minus =
-  -- least significat bit first substraction with carry
-  ${bits x, bits y, carry c}
+_minus = {.x x, .y y, .c c, 0b r} _minus_;
+
+_minus_ =
+  -- least significant bit first substraction with carry
+  ${bits x, bits y, carry c, bits r}
   <
-    {.x then, .y empty? if, .c/0 and} .then,
-    {.x/1 then, .y empty? if, .c/1 and} .then 0_,
-    {.x/0 x, .y empty? y, .c/1 c1 c} _minus 1_,
-    {.x/0 x, .y/0   y, .c/0 c0 c} _minus 0_,
-    {.x/0 x, .y/0   y, .c/1 c1 c} _minus 1_,  
-    {.x/0 x, .y/1   y, .c/0 c1 c} _minus 1_,
-    {.x/0 x, .y/1   y, .c/1 c1 c} _minus 0_,
-    {.x/1 x, .y/0   y, .c/0 c0 c} _minus 1_,
-    {.x/1 x, .y/0   y, .c/1 c0 c} _minus 0_,
-    {.x/1 x, .y/1   y, .c/0 c0 c} _minus 0_,
-    {.x/1 x, .y/1   y, .c/1 c1 c} _minus 1_
+    {.y empty? if, .c/0 and, {.r x, .x r} _inv then} .then,
+    <
+      {.x/0 x, .y empty? y, .c/1 c1 c, .r |1 r},
+      {.x/1 x, .y empty? y, .c/1 c0 c, .r |0 r},
+
+      {.x/0 x, .y/0   y, .c/0 c0 c, .r |0 r},
+      {.x/0 x, .y/0   y, .c/1 c1 c, .r |1 r},  
+      {.x/0 x, .y/1   y, .c/0 c1 c, .r |1 r},
+      {.x/0 x, .y/1   y, .c/1 c1 c, .r |0 r},
+      {.x/1 x, .y/0   y, .c/0 c0 c, .r |1 r},
+      {.x/1 x, .y/0   y, .c/1 c0 c, .r |0 r},
+      {.x/1 x, .y/1   y, .c/0 c0 c, .r |0 r},
+      {.x/1 x, .y/1   y, .c/1 c1 c, .r |1 r}
+    > _minus_
   >
 ;
 
@@ -209,23 +232,25 @@ _times =
   ${bits result, bits _x, bits y}
   <
     { .y empty? if, .result then } .then,
-    { 
-      .result 0_ result, 
-      ._x _x, 
-      .y /0 y
-    } _times,
-    { 
-      {._x x, .result 0_ y, c0 c } _plus result, 
-      ._x _x, 
-      .y /1 y 
-    } _times
+    <
+      { 
+        .result |0  result, 
+        ._x _x, 
+        .y /0 y
+      },
+      { 
+        {._x x, .result |0  y, c0 c } _plus result, 
+        ._x _x, 
+        .y /1 y 
+      }
+    > _times
   >
 ;
 
 
 mod =
   ${bits x, bits y}
-  _log!
+  -- _log!
   < 
     -- if y > x then (x mod y) = x 
     {.y x, .x y} GT .y,
@@ -234,7 +259,7 @@ mod =
     { 
       {  
         {.x int x, .y int y} minus /"+" x, 
-        .y inv 0_ inv y
+        .y inv |0  inv y
       } mod x, 
       .y y 
     } mod
@@ -278,7 +303,7 @@ x_times_2_to_k =
 
 _x_times_2_to_the_power_of_k = <
   {.k zero_int? if, ._x then} .then,
-  {._x 0_ _x, .k dec k} _x_times_2_to_the_power_of_k
+  {._x |0  _x, .k dec k} _x_times_2_to_the_power_of_k
 >
 ;
  
@@ -324,17 +349,18 @@ lcm =
   {{.x int x, .y int y} times x, gcd int y} div .div abs
 ;
 
- factorial = <
-  zero_int? 1 int,
-  /"+" int {dec factorial x, () y} times
+factorial = {()n, 1 int acc} factorial_;
+factorial_ =  <
+  {.n zero_int? if, .acc then} .then,
+  {.n pos? dec n, {.n x, .acc y} times acc} factorial_
 >;
 
 fib_ =
   <
+    {.n int zero_int? if, ."fib(n),fib(n.1)" then} .then,
     { .n int dec /"+" n,
       ."fib(n),fib(n.1)" {plus x, .x y} "fib(n),fib(n.1)"
-    } fib_,
-    ."fib(n),fib(n.1)"
+    } fib_
   >
 ;
 
@@ -442,7 +468,7 @@ ratToString =
 
 _rat! = $rat {
   () carryOn, 
-  ratToString _log! drop
+  ratToString drop
  } .carryOn;
 
 

package/Examples/bnat.k

@@ -288,4 +288,4 @@ _sqrt =
 
 --------------------
 
-_log! lcm 
+lcm 

package/Examples/buda.k

@@ -0,0 +1,44 @@
+// we will use arithmetics.k
+
+nths = ?{$int n, LIST list} 
+  < 
+    {.n pos? dec n, .list cdr list } nths,
+    {.n zero_int? if, .list list? car then} .then
+  >;
+
+reverse = ? LIST  list?
+  {nil ? LIST reversed, () list } _reverse;
+  
+_reverse = ?{ LIST reversed, LIST list} 
+  <   
+    {{.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 odd, LIST even, LIST list }
+  < 
+    { 
+        {.list car car, .odd cdr} cons odd,
+        .even even,
+        .list cdr list
+    } split_,
+
+    {.odd odd, .even even}
+  >
+;
+
+split_ = ? { LIST odd, LIST even, LIST list }
+  < 
+    { 
+        .odd odd,
+        {.list car car, .even cdr} cons even,
+        .list cdr list
+    } _split,
+    {.odd odd, .even even}
+  >
+;