add curried counter-part

Author: bobzhang

jscomp/others/bs_Array.ml

@@ -90,7 +90,7 @@ let make l f =
 
 (* See #6575. We could also check for maximum array size, but this depends
      on whether we create a float array or a regular one... *)
-let makeBy l f =
+let makeByU l f =
   if l <= 0 then [||]
   else 
     let res = makeUninitializedUnsafe l in 
@@ -99,11 +99,14 @@ let makeBy l f =
     done;
     res
 
-let makeByAndShuffle l f =
-  let u  = makeBy l f in
+let makeBy l f = makeByU l (fun[@bs] a -> f a) 
+
+let makeByAndShuffleU l f =
+  let u  = makeByU l f in
   shuffleInPlace u ;
   u
 
+let makeByAndShuffle l f = makeByAndShuffleU l (fun[@bs] a -> f a)
 
 
 
@@ -116,7 +119,7 @@ let zip xs ys =
   done ; 
   s 
 
-let zipBy xs ys f = 
+let zipByU xs ys f = 
   let lenx, leny = length xs, length ys in 
   let len = Pervasives.min lenx leny  in 
   let s = makeUninitializedUnsafe len in 
@@ -125,6 +128,8 @@ let zipBy xs ys f =
   done ; 
   s 
 
+let zipBy xs ys f = zipByU xs ys (fun [@bs] a b -> f a b)
+
 let concat a1 a2 =
   let l1 = length a1 in
   let l2 = length a2 in 
@@ -216,19 +221,22 @@ let blit ~src:a1 ~srcOffset:ofs1 ~dst:a2 ~dstOffset:ofs2 ~len =
         setUnsafe a2 (j + srcofs2) (getUnsafe a1 (j + srcofs1))
       done 
 
-let forEach a f =
+let forEachU a f =
   for i = 0 to length a - 1 do f(getUnsafe a i) [@bs] done
 
-let map a f =
+let forEach a f = forEachU a (fun[@bs] a -> f a)
+  
+let mapU a f =
   let l = length a in
   let r = makeUninitializedUnsafe l in 
   for i = 0 to l - 1 do
     setUnsafe r i (f(getUnsafe a i) [@bs])
   done;
   r
+
+let map a f = mapU a (fun[@bs] a -> f a)
 
-  
-let keep a f =
+let keepU a f =
   let l = length a in
   let r = makeUninitializedUnsafe l in
   let j = ref 0 in 
@@ -243,7 +251,9 @@ let keep a f =
   truncateToLengthUnsafe r !j;
   r 
 
-let keepMap a f =
+let keep a f = keepU a (fun [@bs] a -> f a)
+    
+let keepMapU a f =
   let l = length a in
   let r = makeUninitializedUnsafe l in
   let j = ref 0 in 
@@ -260,55 +270,69 @@ let keepMap a f =
   truncateToLengthUnsafe r !j;
   r 
 
-let forEachWithIndex a f=
+let keepMap a f = keepMapU a (fun[@bs] a -> f a)
+    
+let forEachWithIndexU a f=
   for i = 0 to length a - 1 do f i (getUnsafe a i) [@bs] done
 
-let mapWithIndex  a f =
+let forEachWithIndex a f = forEachWithIndexU a (fun[@bs] a b -> f a b)
+    
+let mapWithIndexU  a f =
   let l = length a in
   let r = makeUninitializedUnsafe l in 
   for i = 0 to l - 1 do
     setUnsafe r i (f i (getUnsafe a i) [@bs])
   done;
   r
 
-let reduce a x f =
+let mapWithIndex a f = mapWithIndexU a (fun[@bs] a b -> f a b)
+  
+let reduceU a x f =
   let r = ref x in
   for i = 0 to length a - 1 do
     r := f !r (getUnsafe a i) [@bs]
   done;
   !r
 
-let reduceReverse a x f =
+let reduce a x f = reduceU a x (fun[@bs] a b -> f a b)
+    
+let reduceReverseU a x f =
   let r = ref x in
   for i = length a - 1 downto 0 do
     r := f  !r (getUnsafe a i) [@bs]
   done;
   !r
 
+let reduceReverse a x f = reduceReverseU a x (fun[@bs] a b -> f a b)
 
 let rec everyAux arr i b len =   
   if i = len then true 
   else if b (getUnsafe arr i) [@bs] then 
     everyAux arr (i + 1) b len
   else false    
 
-let every arr b =   
+let everyU arr b =   
   let len = length arr in 
   everyAux arr 0 b len 
 
+let every arr f = everyU arr (fun[@bs] b -> f b)
+
 let rec everyAux2 arr1 arr2 i b len =   
   if i = len then true 
   else if b (getUnsafe arr1 i) (getUnsafe arr2 i) [@bs] then 
     everyAux2 arr1 arr2 (i + 1) b len
   else false      
 
-let every2  a b p =   
+let every2U  a b p =   
   let lena = length a in  
   let lenb = length b in 
   if lena <> lenb then false
   else 
     everyAux2  a b 0 p lena
 
+let every2 a b p = every2U  a b (fun[@bs] a b -> p a b)
+    
+let eqU = every2U
 let eq = every2
 
 let rec everyCmpAux2 arr1 arr2 i b len =   
@@ -319,14 +343,14 @@ let rec everyCmpAux2 arr1 arr2 i b len =
       everyCmpAux2 arr1 arr2 (i + 1) b len
     else c
 
-let cmp a b p =
+let cmpU a b p =
   let lena = length a in  
   let lenb = length b in
   if lena > lenb then 1
   else if lena < lenb then -1
   else everyCmpAux2 a b 0 p lena
 
-
+let cmp a b p = cmpU a b (fun[@bs] a b -> p a b)
 
 
 

jscomp/others/bs_Array.mli

@@ -74,14 +74,16 @@ val make: int -> 'a  -> 'a array
     return an array of size [n] with value [e]
  *)
 
-val makeBy: int -> (int -> 'a [@bs]) -> 'a array
+val makeByU: int -> (int -> 'a [@bs]) -> 'a array
+val makeBy: int -> (int -> 'a ) -> 'a array
 (** [makeBy n f] 
     
     return an empty array when [n] is negative 
     return an array of size [n] populated by [f i] start from [0] to [n - 1]
 *)
 
-val makeByAndShuffle: int -> (int -> 'a [@bs]) -> 'a array
+val makeByAndShuffleU: int -> (int -> 'a [@bs]) -> 'a array
+val makeByAndShuffle: int -> (int -> 'a ) -> 'a array    
 (** [makeByAndShuffle n f] is semantically equivalent to [makeBy n f]
     and return the shuffled array  *)    
 
@@ -93,7 +95,8 @@ val zip: 'a array -> 'b array -> ('a * 'b) array
  *)
 
 
- val zipBy: 'a array -> 'b array -> ('a -> 'b -> 'c [@bs]) -> 'c array    
+ val zipByU: 'a array -> 'b array -> ('a -> 'b -> 'c [@bs]) -> 'c array
+ val zipBy: 'a array -> 'b array -> ('a -> 'b -> 'c ) -> 'c array         
  (**
     [zipBy a b f]
    
@@ -166,39 +169,51 @@ val blitUnsafe:
   src:'a array -> srcOffset:int -> dst:'a array -> dstOffset:int -> len:int -> unit 
 
 
-val forEach: 'a array ->  ('a -> unit [@bs]) -> unit
+val forEachU: 'a array ->  ('a -> unit [@bs]) -> unit
+val forEach: 'a array ->  ('a -> unit ) -> unit
 
-val map: 'a array ->  ('a -> 'b [@bs]) -> 'b array
+val mapU: 'a array ->  ('a -> 'b [@bs]) -> 'b array
+val map: 'a array ->  ('a -> 'b ) -> 'b array
 
-val keep: 'a array -> ('a -> bool [@bs]) -> 'a array
+val keepU: 'a array -> ('a -> bool [@bs]) -> 'a array
+val keep: 'a array -> ('a -> bool ) -> 'a array
 
-val keepMap: 'a array -> ('a -> 'b option [@bs]) -> 'b array 
-    
-val forEachWithIndex: 'a array ->  (int -> 'a -> unit [@bs]) -> unit
-
-val mapWithIndex: 'a array ->  (int -> 'a -> 'b [@bs]) -> 'b array
 
-val reduce:  'b array -> 'a -> ('a -> 'b -> 'a [@bs]) ->'a
+val keepMapU: 'a array -> ('a -> 'b option [@bs]) -> 'b array
+val keepMap: 'a array -> ('a -> 'b option) -> 'b array 
+    
+val forEachWithIndexU: 'a array ->  (int -> 'a -> unit [@bs]) -> unit
+val forEachWithIndex: 'a array ->  (int -> 'a -> unit ) -> unit
 
-val reduceReverse: 'b array -> 'a -> ('a -> 'b ->  'a [@bs]) ->  'a
+val mapWithIndexU: 'a array ->  (int -> 'a -> 'b [@bs]) -> 'b array
+val mapWithIndex: 'a array ->  (int -> 'a -> 'b ) -> 'b array    
 
-val every: 'a array -> ('a -> bool [@bs]) -> bool
+val reduceU:  'b array -> 'a -> ('a -> 'b -> 'a [@bs]) ->'a
+val reduce:  'b array -> 'a -> ('a -> 'b -> 'a ) ->'a
 
+val reduceReverseU: 'b array -> 'a -> ('a -> 'b ->  'a [@bs]) ->  'a
+val reduceReverse: 'b array -> 'a -> ('a -> 'b ->  'a ) ->  'a
+  
+val everyU: 'a array -> ('a -> bool [@bs]) -> bool
+val every: 'a array -> ('a -> bool ) -> bool
 
-val every2: 'a array -> 'b array -> ('a -> 'b -> bool [@bs]) -> bool
+val every2U: 'a array -> 'b array -> ('a -> 'b -> bool [@bs]) -> bool
+val every2: 'a array -> 'b array -> ('a -> 'b -> bool ) -> bool
 (** [every2 a b p] 
     - return false when [length a <> length b] 
     - return true when every pair is true [f ai bi]
 *)
 
-val cmp: 'a array -> 'a array -> ('a -> 'a -> int [@bs]) -> int
+val cmpU: 'a array -> 'a array -> ('a -> 'a -> int [@bs]) -> int
+val cmp: 'a array -> 'a array -> ('a -> 'a -> int ) -> int
 (** [cmp a b]
     
     if [length a <> length b] compared by length
     otherwise compare one by one [f ai bi]
 *)
 
-val eq:  'a array -> 'a array -> ('a -> 'a -> bool [@bs]) -> bool
+val eqU:  'a array -> 'a array -> ('a -> 'a -> bool [@bs]) -> bool
+val eq:  'a array -> 'a array -> ('a -> 'a -> bool ) -> bool
 (** [eq a b]
     
     - return false if length is not the same

jscomp/others/bs_Dict.ml

@@ -39,7 +39,8 @@ module type Comparable = sig
   val cmp: (t, id) cmp
 end
 
-type ('key, 'id) comparable = (module Comparable with type t = 'key and type id = 'id)
+type ('key, 'id) comparable =
+  (module Comparable with type t = 'key and type id = 'id)
 
 
 module MakeComparable (M : sig
@@ -52,7 +53,7 @@ struct
   let cmp = M.cmp
 end
 
-let comparable
+let comparableU
   (type key) 
   ~cmp   
   =
@@ -63,6 +64,9 @@ let comparable
   (module N : Comparable with type t = key)
 
 
+let comparable ~cmp =
+  comparableU ~cmp:(fun[@bs] a b -> cmp a b)
+    
 module type Hashable = sig 
   type id 
   type t 
@@ -84,10 +88,15 @@ struct
   let eq = M.eq
 end
 
-let hashable (type key) ~hash ~eq = 
+let hashableU (type key) ~hash ~eq = 
   let module N = MakeHashable(struct 
     type t = key 
     let hash = hash 
     let eq = eq 
   end) in 
   (module N : Hashable with type t = key) 
+
+let hashable ~hash ~eq =
+  hashableU
+    ~hash:(fun [@bs] a -> hash a)
+    ~eq:(fun [@bs] a b -> eq a b)

jscomp/others/bs_Dict.mli

@@ -62,7 +62,8 @@ module type Comparable = sig
   val cmp: (t, id) cmp
 end
 
-type ('key, 'id) comparable = (module Comparable with type t = 'key and type id = 'id)
+type ('key, 'id) comparable =
+  (module Comparable with type t = 'key and type id = 'id)
 (** [('key, 'id) cmparable] is a module of functions, here it only includes [cmp].
 
     Unlike normal functions, when created, it comes with a unique identity (guaranteed
@@ -74,19 +75,23 @@ type ('key, 'id) comparable = (module Comparable with type t = 'key and type id
     mismatch if they use different comparison function
 *)
 
-val comparable:
+val comparableU:
   cmp:('a -> 'a -> int [@bs]) ->
   (module Comparable with type t = 'a)
 
-
+val comparable:
+  cmp:('a -> 'a -> int) -> 
+  (module Comparable with type t = 'a)
+  
 module type Hashable = sig 
   type id 
   type t 
   val hash: (t,id) hash
   val eq:  (t,id) eq
 end 
 
-type ('key, 'id) hashable = (module Hashable with type t = 'key and type id = 'id)
+type ('key, 'id) hashable =
+  (module Hashable with type t = 'key and type id = 'id)
 (** [('key, 'id) hashable] is a module of functions, here it only includes [hash], [eq].
     
     Unlike normal functions, when created, it comes with a unique identity (guaranteed
@@ -100,9 +105,17 @@ type ('key, 'id) hashable = (module Hashable with type t = 'key and type id = 'i
 
 
 
-val hashable:
+val hashableU:
   hash:('a -> int [@bs]) ->
-  eq:('a -> 'a -> bool [@bs]) -> (module Hashable with type t = 'a)
+  eq:('a -> 'a -> bool [@bs]) ->
+  (module Hashable with type t = 'a)
+  
+val hashable:
+  hash:('a -> int ) ->
+  eq:('a -> 'a -> bool ) ->
+  (module Hashable with type t = 'a)
+
+
 
 (**/**)
 external getHashInternal : ('a,'id) hash -> ('a -> int [@bs]) = "%identity"