Transform 0 arguments closure to direct function calls as recommended by Jose

Author: CryptoPascal31

pact/contracts/util-lists.pact

@@ -46,7 +46,7 @@
 
   (defun chain:list (in:list)
     "Chain list of lists"
-    (fold (+) [] in))
+    (fold + [] in))
 
   (defun same-length:bool (x:list y:list)
     "Return true if two lists have the same length"
@@ -94,7 +94,7 @@
     (if (contains item in)
         (let ((indexes (enumerate 0 (length in)))
               (match (lambda (v i) (if (= item v) i -1))))
-          (remove-item (zip (match) in indexes) -1))
+          (remove-item (zip match in indexes) -1))
         [])
   )
 

pact/contracts/util-math.pact

@@ -42,15 +42,15 @@
   (defun min-list:decimal (x:[decimal])
     "Returns the min of a list"
     (enforce-not-empty x)
-    (fold (min) (first x) (remove-first x))
+    (fold min (first x) (remove-first x))
   )
 
   (defun amin:integer (in:[decimal])
     "Returns the min index of a list"
     (enforce-not-empty in)
     (let ((in-enum (enumerate-list in))
           (cmp (lambda (x y) (if (< (at 'v x) (at 'v y)) x y))))
-      (at 'i (fold (cmp) (first in-enum) (remove-first in-enum))))
+      (at 'i (fold cmp (first in-enum) (remove-first in-enum))))
   )
 
   (defun max:decimal (x:decimal y:decimal)
@@ -68,15 +68,15 @@
   (defun max-list:decimal (x:[decimal])
     "Returns the max of a list"
     (enforce-not-empty x)
-    (fold (max) (first x) (remove-first x))
+    (fold max (first x) (remove-first x))
   )
 
   (defun amax:integer (in:[decimal])
     "Returns the max index of a list"
     (enforce-not-empty in)
     (let ((in-enum (enumerate-list in))
           (cmp (lambda (x y) (if (> (at 'v x) (at 'v y)) x y))))
-      (at 'i (fold (cmp) (first in-enum) (remove-first in-enum))))
+      (at 'i (fold cmp (first in-enum) (remove-first in-enum))))
   )
 
   (defun clamp:decimal (low-limit:decimal up-limit:decimal x:decimal)
@@ -97,7 +97,7 @@
 
   (defun sum:decimal (x:[decimal])
     "Returns the sum of a list"
-    (fold (+) 0.0 x))
+    (fold + 0.0 x))
 
   (defun prod3:decimal (x:decimal y:decimal z:decimal)
     "Returns the product of 3 values"
@@ -109,7 +109,7 @@
 
   (defun prod:decimal (x:[decimal])
     "Returns the product of a list"
-    (fold (*) 1.0 x))
+    (fold * 1.0 x))
 
   (defun square:decimal (x:decimal)
     "Returns the square of x"
@@ -213,7 +213,7 @@
                 (gcd-inner (lambda (x i) (if (= (at 'b x) 0)
                                              x
                                              {'a: (at 'b x), 'b: (mod (at 'a x) (at 'b x))})))
-                (gcd-result (fold (gcd-inner) {'a:a*, 'b:b*} (enumerate 1 max-iterations))))
+                (gcd-result (fold gcd-inner {'a:a*, 'b:b*} (enumerate 1 max-iterations))))
             (enforce (= (at 'b gcd-result) 0) "Euclidean algorithm not finished")
             (at 'a gcd-result))))
   )

pact/contracts/util-random.pact

@@ -119,7 +119,7 @@
           (assign-order (lambda (x i) {'order:i, 'val:x })))
       (map (at 'val)
            (sort ['order]
-                 (zip (assign-order) in (map (hash) indexes)))))
+                 (zip assign-order in (map (hash) indexes)))))
   )
 
   (defun gen-uuid-rfc-4122-v4:string ()

pact/contracts/util-strings.pact

@@ -55,8 +55,7 @@
 
   (defun str-to-ascii-int:integer (in:string)
     "Convert a string to its integer ASCII representation"
-    (let ((shift-add (lambda (x y) (+ (shift x 8) y))))
-      (fold (shift-add) 0 (decode-ascii in)))
+    (fold (lambda (x y) (+ (shift x 8) y)) 0 (decode-ascii in))
   )
 
   (defun encode-ascii:string (in-list:[integer])
@@ -72,7 +71,7 @@
     (if (!= in 0)
         (let ((len (ceiling (log 256.0 (dec in))))
               (extract-char-value (lambda (idx) (mod (shift in (* -8 idx)) 256))))
-          (encode-ascii (map (extract-char-value) (enumerate (- len 1) 0))))
+          (encode-ascii (map extract-char-value (enumerate (- len 1) 0))))
         "")
   )
 
@@ -100,7 +99,7 @@
     "Returns true if in contains one of the characters in values"
     (let ((values-lists (str-to-list values))
           (contains-char (lambda (x) (contains x in))))
-      (fold (or) false (map (contains-char) values-lists)))
+      (fold (or) false (map contains-char values-lists)))
   )
 
   (defun replace-char:string (in:string old-char:string new-char:string)
@@ -114,7 +113,7 @@
                             (if (and? (<= 97) (>= 122) x)
                                 (- x 32)
                                 x))))
-      (encode-ascii (map (do-upper) (decode-ascii in))))
+      (encode-ascii (map do-upper (decode-ascii in))))
   )
 
   (defun lower:string (in:string)
@@ -123,7 +122,7 @@
                             (if (and? (<= 65) (>= 90) x)
                                 (+ x 32)
                                 x))))
-      (encode-ascii (map (do-lower) (decode-ascii in))))
+      (encode-ascii (map do-lower (decode-ascii in))))
   )
 
   (defun char-at:string (idx:integer in:string)
@@ -151,9 +150,9 @@
       [] ;If the string is empty return a zero length list
       (let ((sep-pos (search (str-to-list in) separator))
             (substart (map (+ 1) (insert-first sep-pos -1)))
-            (sublen  (zip (-) (append-last sep-pos 10000000) substart))
+            (sublen  (zip - (append-last sep-pos 10000000) substart))
             (cut (lambda (start len) (take len (drop start in)))))
-        (zip (cut) substart sublen)))
+        (zip cut substart sublen)))
   )
 
   (defun split-chunks:[string] (chunk-size:integer in:string)
@@ -164,7 +163,7 @@
            (take-chunk (lambda (x) (take chunk-size (drop (* x chunk-size) in)))))
       (if (= 0 out-len)
           []
-          (map (take-chunk) (enumerate 0 (- out-len 1)))))
+          (map take-chunk (enumerate 0 (- out-len 1)))))
   )
 
   (defun starts-with:bool (in:string to-match:string)

pact/contracts/util-zk.pact

@@ -73,7 +73,7 @@
   (defun serialize-proof:string (proof:object{groth16-proof})
     "Serialiaze an object proof to its base64 representation (344 octets)"
     (bind proof {'A:=A, 'B:=B, 'C:=C}
-      (concat (map (int256-to-b64) [ (at 'x A), (at 'y A),
+      (concat (map int256-to-b64   [ (at 'x A), (at 'y A),
                                      (at 0 (at 'x B)), (at 1 (at 'x B)),
                                      (at 0 (at 'y B)), (at 1 (at 'y B)),
                                      (at 'x C), (at 'y C)