clean up argument order

Author: bobzhang

jscomp/others/bs_Map.ml

@@ -38,7 +38,7 @@ let partition0 = N.partition0
 let length0 = N.length0
 let toList0 = N.toList0
 
-let rec add0 ~cmp x data (t : _ t0) =
+let rec add0  (t : _ t0) x data  ~cmp =
   match N.toOpt t with (* TODO: test case with the same key *)
     None ->
     N.(return @@ node ~left:empty ~key:x ~value:data ~right:empty ~h:1)
@@ -48,41 +48,41 @@ let rec add0 ~cmp x data (t : _ t0) =
     if c = 0 then
       N.(return @@ node ~left:l ~key:x ~value:data ~right:r ~h:(h n))
     else if c < 0 then
-      N.(bal (add0 ~cmp x data l) k v  r)
+      N.(bal (add0 ~cmp l x data ) k v  r)
     else
-      N.(bal l k v (add0 ~cmp x data r))
+      N.(bal l k v (add0 ~cmp r x data ))
 
-let rec findOpt0 ~cmp x n = 
+let rec findOpt0  n x ~cmp = 
   match N.toOpt n with 
     None -> None
   | Some n (* Node(l, v, d, r, _) *)  ->
     let v = N.key n in 
     let c = (Bs_Cmp.getCmp cmp) x v [@bs] in
     if c = 0 then Some (N.value n)
-    else findOpt0 ~cmp x (if c < 0 then N.left n else N.right n)
+    else findOpt0 ~cmp  (if c < 0 then N.left n else N.right n) x 
 
-let rec findAssert0 ~cmp x n =
+let rec findAssert0  n x ~cmp =
   match N.toOpt n with 
   | None -> 
     [%assert "Not_found"]
   | Some n (* Node(l, v, d, r, _)*) ->
     let v = N.key n in 
     let c = (Bs_Cmp.getCmp cmp) x v [@bs] in
     if c = 0 then N.value n 
-    else findAssert0 ~cmp x (if c < 0 then N.left n else N.right n)
+    else findAssert0 ~cmp  (if c < 0 then N.left n else N.right n) x 
 
-let rec findWithDefault0 ~cmp ~def x n = 
+let rec findWithDefault0   n x def ~cmp = 
   match N.toOpt n with 
     None ->
     def
   | Some n (* Node(l, v, d, r, _)*) ->
     let v = N.key n in 
     let c = (Bs_Cmp.getCmp cmp) x v [@bs] in
     if c = 0 then N.value n 
-    else findWithDefault0 ~cmp ~def x (if c < 0 then N.left n else N.right n)
+    else findWithDefault0 ~cmp  (if c < 0 then N.left n else N.right n) x def
 
 
-let rec mem0 ~cmp x n = 
+let rec mem0  x n ~cmp = 
   match N.toOpt n with 
     None ->
     false
@@ -92,7 +92,7 @@ let rec mem0 ~cmp x n =
     c = 0 || mem0 ~cmp x (if c < 0 then N.left n else N.right n)
 
 
-let rec remove0 ~cmp x n = 
+let rec remove0  n x ~cmp = 
   match N.toOpt n with 
     None ->
     n
@@ -108,9 +108,9 @@ let rec remove0 ~cmp x n =
         let r = N.removeMinAuxWithRef rn kr vr in 
         N.bal l !kr !vr r
     else if c < 0 then
-      N.(bal (remove0 ~cmp x l) v (value n) r)
+      N.(bal (remove0 ~cmp l x ) v (value n) r)
     else
-      N.(bal l v (value n) (remove0 ~cmp x r))
+      N.(bal l v (value n) (remove0 ~cmp r x ))
 
 let rec splitAux ~cmp x (n : _ N.node) : _ t0 * _ option  * _ t0 =  
   let l,v,d,r = N.(left n , key n, value n, right n) in  
@@ -138,17 +138,17 @@ let split0 ~cmp x n =
   | Some n (* Node(l, v, d, r, _) *) ->
     splitAux ~cmp x n 
 
-let rec merge0 ~cmp f s1 s2 =
+let rec merge0 s1 s2 f ~cmp =
   match N.(toOpt s1, toOpt s2) with
     (None, None) -> N.empty
   | Some n (* (Node (l1, v1, d1, r1, h1), _) *), _ when N.h n  >= N.height s2 ->
     let l1, v1, d1, r1 = N.(left n, key n, value n, right n) in 
     let (l2, d2, r2) = split0 ~cmp v1 s2 in
-    N.concatOrJoin (merge0 ~cmp f l1 l2) v1 (f v1 (Some d1) d2 [@bs]) (merge0 ~cmp f r1 r2)
+    N.concatOrJoin (merge0 ~cmp l1 l2 f) v1 (f v1 (Some d1) d2 [@bs]) (merge0 ~cmp r1 r2 f)
   | _, Some n (* Node (l2, v2, d2, r2, h2)*) ->
     let l2,v2,d2,r2 = N.(left n, key n, value n, right n) in 
     let (l1, d1, r1) = split0 ~cmp v2 s1 in
-    N.concatOrJoin (merge0 ~cmp f l1 l2) v2 (f v2 d1 (Some d2) [@bs]) (merge0 ~cmp f r1 r2)
+    N.concatOrJoin (merge0 ~cmp l1 l2 f) v2 (f v2 d1 (Some d2) [@bs]) (merge0 ~cmp r1 r2 f)
   | _ ->
     assert false
 
@@ -194,7 +194,7 @@ let ofArray0 ~cmp (xs : _ array) : _ t0 =
   let result = ref N.empty in 
   for i = 0 to Array.length xs - 1 do  
     let k, v = (Bs_Array.unsafe_get xs i) in 
-    result := add0 ~cmp  k v !result
+    result := add0 ~cmp !result k v 
   done ;
   !result 
 
@@ -253,10 +253,10 @@ let mapi map  f =
 
 
 
-let add (type k) (type v) (type id) key data (map : (k,v,id) t) = 
+let add (type k) (type v) (type id) (map : (k,v,id) t) key data  = 
   let dict,map = B.(dict map, data map) in 
   let module X = (val dict) in 
-  B.bag ~dict ~data:(add0 ~cmp:X.cmp key data map)
+  B.bag ~dict ~data:(add0 ~cmp:X.cmp map key data )
 
 
 let ofArray (type k) (type v) (type id) (dict : (k,id) Bs_Cmp.t) data = 
@@ -267,31 +267,31 @@ let ofArray (type k) (type v) (type id) (dict : (k,id) Bs_Cmp.t) data =
 
 
 
-let findOpt (type k) (type v) (type id) x (map : (k,v,id) t) = 
+let findOpt (type k) (type v) (type id) (map : (k,v,id) t) x  = 
   let dict,map = B.(dict map, data map) in 
   let module X = (val dict) in 
-  findOpt0 ~cmp:X.cmp x map
+  findOpt0 ~cmp:X.cmp  map x 
 
-let findAssert (type k) (type v) (type id) x (map : (k,v,id) t) = 
+let findAssert (type k) (type v) (type id) (map : (k,v,id) t) x = 
   let dict,map = B.(dict map, data map) in 
   let module X = (val dict) in 
-  findAssert0 ~cmp:X.cmp x map
+  findAssert0 ~cmp:X.cmp  map x
 
-let findWithDefault (type k) (type v) (type id) ~def x (map : (k,v,id) t) = 
+let findWithDefault (type k) (type v) (type id)  (map : (k,v,id) t) x def = 
   let dict,map = B.(dict map, data map) in 
   let module X = (val dict) in 
-  findWithDefault0 ~cmp:X.cmp ~def x map
+  findWithDefault0 ~cmp:X.cmp map x  def
 
 
-let mem (type k) (type v) (type id) x (map : (k,v,id) t) = 
+let mem (type k) (type v) (type id)  (map : (k,v,id) t) x = 
   let dict,map = B.(dict map, data map) in 
   let module X = (val dict) in 
   mem0 ~cmp:X.cmp x map
 
-let remove (type k) (type v) (type id) x (map : (k,v,id) t) =   
+let remove (type k) (type v) (type id) (map : (k,v,id) t) x  =   
   let dict,map = B.(dict map, data map) in 
   let module X = (val dict) in 
-  B.bag ~dict ~data:(remove0 ~cmp:X.cmp x map)
+  B.bag ~dict ~data:(remove0 ~cmp:X.cmp map x )
 
 let split (type k) (type v) (type id) x (map : (k,v,id) t) =   
   let dict,map = B.(dict map, data map) in 
@@ -306,11 +306,11 @@ let split (type k) (type v) (type id) x (map : (k,v,id) t) =
     ~data:r
 
 
-let merge (type k) (type v) (type id) f (s1 : (k,v,id) t) 
-    (s2 : (k,_,id) t) = 
+let merge (type k) (type v) (type id)  (s1 : (k,v,id) t) 
+    (s2 : (k,_,id) t) f = 
   let dict, s1_data, s2_data = B.(dict s1, data s1, data s2) in 
   let module X = (val dict) in 
-  B.bag ~data:(merge0 ~cmp:X.cmp f s1_data s2_data )
+  B.bag ~data:(merge0 ~cmp:X.cmp  s1_data s2_data f)
     ~dict