Merge pull request #2467 from BuckleScript/clean_up_list_interface_pe…

…r_feedback

clean up address comments

jscomp/others/bs_Map.ml

@@ -305,7 +305,7 @@ let partition m p =
 let map m f = 
   let dict, map = B.(dict m, data m) in 
   B.bag ~dict ~data:(N.map0 map f)
-let mapi m  f = 
+let mapWithKey m  f = 
   let dict,map = B.(dict m, data m) in 
   B.bag ~dict ~data:(N.mapi0 map f)
 
@@ -321,39 +321,34 @@ let keysToArray m =
 let valuesToArray m =   
   N.valuesToArray0 (B.data m)
 
-let minKeyOpt m = N.minKeyOpt0 (B.data m)
+let minKey m = N.minKeyOpt0 (B.data m)
 let minKeyNull m = N.minKeyNull0 (B.data m)
-let maxKeyOpt m = N.maxKeyOpt0 (B.data m)
+let maxKey m = N.maxKeyOpt0 (B.data m)
 let maxKeyNull m = N.maxKeyNull0 (B.data m)    
 let minimum m = N.minKVOpt0 (B.data m)
 let minNull m = N.minKVNull0 (B.data m) 
 let maximum m = N.maxKVOpt0 (B.data m)
 let maxNull m = N.maxKVNull0 (B.data m)
 
 let get (type k) (type id) (map : (k,_,id) t) x  = 
-  let dict,map = B.(dict map, data map) in 
-  let module X = (val dict) in 
-  N.findOpt0 ~cmp:X.cmp  map x 
+  let module X = (val B.dict map) in 
+  N.findOpt0 ~cmp:X.cmp  (B.data map) x 
 
 let getNull (type k) (type id) (map : (k,_,id) t) x = 
-  let dict,map = B.(dict map, data map) in 
-  let module X = (val dict) in 
-  N.findNull0 ~cmp:X.cmp  map x
+  let module X = (val B.dict map) in 
+  N.findNull0 ~cmp:X.cmp  (B.data map) x
 
 let getWithDefault (type k) (type id)  (map : (k,_,id) t) x def = 
-  let dict,map = B.(dict map, data map) in 
-  let module X = (val dict) in 
-  N.findWithDefault0 ~cmp:X.cmp map x  def
+  let module X = (val B.dict map) in 
+  N.findWithDefault0 ~cmp:X.cmp (B.data map) x  def
 
 let getExn (type k) (type id)  (map : (k,_,id) t) x = 
-  let dict,map = B.(dict map, data map) in 
-  let module X = (val dict) in 
-  N.findExn0 ~cmp:X.cmp map x 
+  let module X = (val B.dict map) in 
+  N.findExn0 ~cmp:X.cmp (B.data map) x 
 
 let has (type k) (type id)  (map : (k,_,id) t) x = 
-  let dict,map = B.(dict map, data map) in 
-  let module X = (val dict) in 
-  N.mem0 ~cmp:X.cmp map x
+  let module X = (val B.dict map) in 
+  N.mem0 ~cmp:X.cmp (B.data map) x
 
 let checkInvariant m  =
   N.checkInvariant (B.data m)

jscomp/others/bs_Map.mli

@@ -40,7 +40,7 @@ type ('k,'v,'id) t
 
 val empty: dict:('k, 'id) Bs_Cmp.t -> ('k, 'a, 'id) t 
 val isEmpty: _ t -> bool
-val singleton: 'k -> 'a -> dict:('k,'id) Bs_Cmp.t -> ('k, 'a, 'id) t
+
 val has: ('k, 'a, 'id) t -> 'k  -> bool    
 val cmp: 
     ('k, 'v, 'id) t -> 
@@ -83,9 +83,9 @@ val toArray: ('k, 'a, 'id) t -> ('k * 'a) array
 val ofArray:  ('k * 'a) array -> dict:('k,'id) Bs_Cmp.t -> ('k,'a,'id) t         
 val keysToArray: ('k, 'a, 'id) t -> 'k  array
 val valuesToArray: ('k, 'a, 'id) t -> 'a  array
-val minKeyOpt: ('k, _, _) t -> 'k option
+val minKey: ('k, _, _) t -> 'k option
 val minKeyNull: ('k, _, _) t -> 'k Js.null
-val maxKeyOpt: ('k, _, _) t -> 'k option
+val maxKey: ('k, _, _) t -> 'k option
 val maxKeyNull: ('k, _, _) t -> 'k Js.null    
 val minimum: ('k, 'a,  _) t -> ('k * 'a) option
 val minNull: ('k, 'a, _) t -> ('k * 'a) Js.null
@@ -158,7 +158,7 @@ val map: ('k, 'a, 'id) t -> ('a -> 'b [@bs]) ->  ('k ,'b,'id ) t
     The bindings are passed to [f] in increasing order
     with respect to the ordering over the type of the keys. *)
 
-val mapi: ('k, 'a, 'id) t -> ('k -> 'a -> 'b [@bs]) -> ('k, 'b, 'id) t
+val mapWithKey: ('k, 'a, 'id) t -> ('k -> 'a -> 'b [@bs]) -> ('k, 'b, 'id) t
 
 
 (****************************************************************************)
@@ -204,7 +204,7 @@ val update0:
   cmp:('k, 'id) Bs_Cmp.cmp -> 
   ('k, 'a, 'id) t0
 
-val singleton0 : 'k -> 'a -> ('k, 'a, 'id) t0    
+
 
 val remove0:
   ('k, 'a, 'id) t0 ->

jscomp/others/bs_MapInt.ml

@@ -13,18 +13,18 @@ let empty = N.empty0
 let isEmpty = N.isEmpty0
 let singleton = N.singleton0
 
-let minKeyOpt = N.minKeyOpt0
+let minKey = N.minKeyOpt0
 let minKeyNull = N.minKeyNull0
-let maxKeyOpt = N.maxKeyOpt0
+let maxKey = N.maxKeyOpt0
 let maxKeyNull = N.maxKeyNull0                   
 let minimum = N.minKVOpt0
 let minNull = N.minKVNull0
 let maximum = N.maxKVOpt0
 let maxNull = N.maxKVNull0
 let forEach = N.iter0      
 let map  = N.map0
-let mapi = N.mapi0
-let fold = N.fold0
+let mapWithKey = N.mapi0
+let reduce = N.fold0
 let every = N.every0
 let some = N.some0    
 let keepBy = N.filterShared0

jscomp/others/bs_MapInt.mli

@@ -6,7 +6,7 @@ type 'a t
 
 val empty: 'a t
 val isEmpty: 'a t -> bool
-val singleton: key -> 'a -> 'a t
+
 val has:  'a t -> key -> bool    
 val cmp:  'a t -> 'a t -> ('a -> 'a -> int [@bs]) -> int
 
@@ -22,7 +22,7 @@ val forEach: 'a t -> (key -> 'a -> unit [@bs]) ->  unit
    as second argument.  The bindings are passed to [f] in increasing
    order with respect to the ordering over the type of the keys. *)
 
-val fold:  'a t -> 'b -> ('b -> key -> 'a -> 'b [@bs]) -> 'b
+val reduce:  'a t -> 'b -> ('b -> key -> 'a -> 'b [@bs]) -> 'b
 (** [reduce m a f] computes [(f kN dN ... (f k1 d1 a)...)],
    where [k1 ... kN] are the keys of all bindings in [m]
    (in increasing order), and [d1 ... dN] are the associated data. *)
@@ -43,9 +43,9 @@ val toArray: 'a t -> (key * 'a) array
 val ofArray: (key * 'a) array -> 'a t     
 val keysToArray: 'a t -> key array 
 val valuesToArray: 'a t -> 'a array
-val minKeyOpt: _ t -> key option 
+val minKey: _ t -> key option 
 val minKeyNull: _ t -> key Js.null
-val maxKeyOpt: _ t -> key option
+val maxKey: _ t -> key option
 val maxKeyNull: _ t -> key Js.null    
 val minimum: 'a t -> (key * 'a) option
 val minNull: 'a t -> (key * 'a) Js.null
@@ -119,7 +119,7 @@ val map: 'a t -> ('a -> 'b [@bs]) ->  'b t
    The bindings are passed to [f] in increasing order
    with respect to the ordering over the type of the keys. *)
 
-val mapi: 'a t -> (key -> 'a -> 'b [@bs]) -> 'b t
+val mapWithKey: 'a t -> (key -> 'a -> 'b [@bs]) -> 'b t
 
 
-val checkInvariant : _ t -> bool 
+val checkInvariant: _ t -> bool 

jscomp/others/bs_MapIntM.ml

@@ -19,26 +19,23 @@ let isEmpty m = N.isEmpty0 (data m)
 let singleton k v = t ~data:(N.singleton0 k v)
 
 let minKeyNull m = N.minKeyNull0 (data m)
-let minKeyOpt m = N.minKeyOpt0 (data m)
+let minKey m = N.minKeyOpt0 (data m)
 let maxKeyNull m = N.maxKeyNull0 (data m)
-let maxKeyOpt m = N.maxKeyOpt0 (data m)
+let maxKey m = N.maxKeyOpt0 (data m)
 let minimum m = N.minKVOpt0 (data m)
 let minNull m = N.minKVNull0 (data m)
 let maximum m = N.maxKVOpt0 (data m)
 let maxNull m = N.maxKVNull0 (data m)
 
-let setDone (m : _ t) k v = 
+let set (m : _ t) k v = 
   let old_data = data m in 
   let v = I.addMutate old_data k v in 
   if v != old_data then 
     dataSet m v 
 
-let set (d : 'a t) (k : key) (v : 'a) : 'a t=  
-  setDone d k v; 
-  d
 let forEach d f = N.iter0 (data d) f     
 let map d f = t ~data:(N.map0 (data d) f)
-let mapi d f = t ~data:(N.mapi0 (data d) f) 
+let mapWithKey d f = t ~data:(N.mapi0 (data d) f) 
 let reduce d acc f  = N.fold0 (data d) acc f 
 let every d f = N.every0 (data d) f 
 let some d f = N.some0 (data d) f    
@@ -78,7 +75,7 @@ let rec removeMutateAux nt (x : key)=
           N.return (N.balMutate nt)
     end
 
-let removeDone d v = 
+let remove d v = 
   let oldRoot = data d in 
   match N.toOpt oldRoot with 
   | None -> ()
@@ -87,9 +84,6 @@ let removeDone d v =
     if newRoot != oldRoot then 
       dataSet d newRoot   
 
-let remove d v = 
-  removeDone d v; 
-  d 
 
 let rec updateDone0 t (x : key)  f  =   
   match N.toOpt t with 
@@ -123,16 +117,14 @@ let rec updateDone0 t (x : key)  f  =
        else   
          N.rightSet nt (updateDone0  r x f);
       );
-      N.return (N.balMutate nt)  
-let updateDone t x f =       
+      N.return (N.balMutate nt)
+
+let update t x f =       
   let oldRoot = data t in 
   let newRoot = updateDone0 oldRoot x f  in 
   if newRoot != oldRoot then 
     dataSet t newRoot 
-
-let update t x f =     
-  updateDone t x f ; 
-  t 
+
 let rec removeArrayMutateAux t xs i len   =  
   if i < len then 
     let ele = A.getUnsafe xs i in 
@@ -142,7 +134,7 @@ let rec removeArrayMutateAux t xs i len   =
     | Some t -> removeArrayMutateAux t xs (i+1) len 
   else N.return t    
 
-let removeArrayDone (type elt) (type id) (d : _ t) xs =  
+let removeMany (type elt) (type id) (d : _ t) xs =  
   let oldRoot = data d in 
   match N.toOpt oldRoot with 
   | None -> ()
@@ -152,9 +144,6 @@ let removeArrayDone (type elt) (type id) (d : _ t) xs =
     if newRoot != oldRoot then 
       dataSet d newRoot
 
-let removeArray d xs =      
-  removeArrayDone d xs; 
-  d  
 
 let cmp = I.cmp 
 let eq = I.eq 

jscomp/others/bs_MapIntM.mli

@@ -31,7 +31,7 @@ type 'a t
 
 val empty: unit -> 'a t
 val isEmpty: 'a t -> bool
-val singleton: key -> 'a -> 'a t
+
 val has:  'a t -> key -> bool
 val cmp:  'a t -> 'a t -> ('a -> 'a -> int [@bs]) -> int
 (** [cmp m1 m2 cmp]
@@ -74,9 +74,9 @@ val toArray: 'a t -> (key * 'a) array
 val ofArray: (key * 'a) array -> 'a t 
 val keysToArray: 'a t -> key array 
 val valuesToArray: 'a t -> 'a array
-val minKeyOpt: _ t -> key option 
+val minKey: _ t -> key option 
 val minKeyNull: _ t -> key Js.null
-val maxKeyOpt: _ t -> key option 
+val maxKey: _ t -> key option 
 val maxKeyNull: _ t -> key Js.null    
 val minimum: 'a t -> (key * 'a) option
 val minNull: 'a t -> (key * 'a) Js.null
@@ -87,24 +87,22 @@ val getNull: 'a t -> key -> 'a Js.null
 val getWithDefault:  'a t -> key -> 'a  -> 'a
 val getExn: 'a t -> key -> 'a
 val checkInvariant: _ t -> bool   
+
 (****************************************************************************)
 
 (*TODO: add functional [merge, partition, keepBy, split]*)
 
-val removeDone: 'a t -> key -> unit  
-val remove: 'a t ->  key -> 'a t
-(** [remove m x] do the in-place modification, return [m] for chaining *)
-val removeArrayDone: 'a t -> key array -> unit
-val removeArray: 'a t -> key array -> 'a t
+val remove: 'a t -> key -> unit  
+(** [remove m x] do the in-place modification *)
+val removeMany: 'a t -> key array -> unit
 
-val setDone: 'a t -> key -> 'a -> unit  
-val set: 'a t ->  key -> 'a -> 'a t
+val set: 'a t -> key -> 'a -> unit  
 (** [add m x y] do the in-place modification, return
     [m] for chaining. If [x] was already bound
    in [m], its previous binding disappears. *)
 
-val updateDone: 'a t -> key -> ('a option -> 'a option [@bs]) -> unit
-val update: 'a t ->  key ->  ('a option -> 'a option [@bs]) -> 'a t 
+val update: 'a t -> key -> ('a option -> 'a option [@bs]) -> unit
+
 
 val map: 'a t -> ('a -> 'b [@bs]) ->  'b t
 (** [map m f] returns a map with same domain as [m], where the
@@ -113,7 +111,7 @@ val map: 'a t -> ('a -> 'b [@bs]) ->  'b t
    The bindings are passed to [f] in increasing order
    with respect to the ordering over the type of the keys. *)
 
-val mapi: 'a t -> (key -> 'a -> 'b [@bs]) -> 'b t
+val mapWithKey: 'a t -> (key -> 'a -> 'b [@bs]) -> 'b t