part 2: finishing hashMap, todo: clean up Array, add specialized HashMapString/Int

Author: bobzhang

jscomp/core/lam_dispatch_primitive.ml

@@ -763,6 +763,10 @@ let translate loc (prim_name : string)
       end
     | "caml_md5_string"
       -> call Js_runtime_modules.md5
+    | "caml_hash_mix_string"
+    | "caml_hash_mix_int"
+    | "caml_hash_final_mix"
+    
     | "caml_hash"
       -> call Js_runtime_modules.hash 
     | "caml_weak_set"

jscomp/others/.depend

@@ -13,6 +13,7 @@ js_obj.cmj :
 js_vector.cmj : js_array.cmj js_vector.cmi
 js_list.cmj : js_vector.cmj js_list.cmi
 js_option.cmj : js_option.cmi
+js_console.cmj :
 js_result.cmj : js_result.cmi
 js_mapperRt.cmj : js_mapperRt.cmi
 bs_Array.cmj : bs_Array.cmi

jscomp/others/Makefile

@@ -6,7 +6,9 @@ MAP_FILES= node bs
 
 SOURCE_LIST= node_path node_fs node_process dict node_module js_array js_string \
 	js_re js_null_undefined node_buffer js_types js_json js_obj \
-	js_vector js_list js_option js_result\
+	js_vector js_list js_option \
+	js_console\
+	js_result\
 	js_mapperRt\
 	bs_Array\
 	bs_internalAVLset\
@@ -28,7 +30,7 @@ $(addsuffix .cmj, $(SOURCE_LIST)): $(addsuffix .cmj, $(MAP_FILES))
 
 RUNTIME := $(addsuffix .cmj, $(SOURCE_LIST)) $(addsuffix .cmi, $(SOURCE_LIST))
 
-BS_COMMON_FLAGS= -no-alias-deps -bs-no-version-header -absname -bs-diagnose -bs-no-check-div-by-zero -bs-cross-module-opt -bs-noassertfalse -bs-package-name bs-platform
+BS_COMMON_FLAGS= -no-alias-deps -bs-no-version-header -absname -bs-diagnose -bs-no-check-div-by-zero -bs-cross-module-opt -bs-noassertfalse -bs-package-name bs-platform 
 
 
 BS_FLAGS=  $(BS_COMMON_FLAGS) $(BS_PKG_FLAGS)

jscomp/others/bs.ml

@@ -30,6 +30,7 @@
 module Cmp = Bs_Cmp
 module Hash = Bs_Hash
 module Array = Bs_Array
+module HashMap = Bs_HashMap
 module Map = Bs_Map
 module Set = Bs_Set
 module MapInt = Bs_MapInt

jscomp/others/bs_Array.ml

@@ -25,28 +25,30 @@ external append_prim : 'a array -> 'a array -> 'a array = "caml_array_append"
 external concat : 'a array list -> 'a array = "caml_array_concat"
 external unsafe_blit :
   'a array -> int -> 'a array -> int -> int -> unit = "caml_array_blit"
-external make_float: int -> float array = "caml_make_float_vect"
+external makeFloat: int -> float array = "caml_make_float_vect"
 
+(*DOC: when l < 0 raise RangeError js excpetion *)
 let init l f =
   if l = 0 then [||] else
-  if l < 0 then invalid_arg "Array.init"
   (* See #6575. We could also check for maximum array size, but this depends
      on whether we create a float array or a regular one... *)
-  else
+  (* if l < 0 then invalid_arg "Array.init"
+  
+  else *)
    let res = create l (f 0 [@bs]) in
    for i = 1 to pred l do
      unsafe_set res i (f i [@bs])
    done;
    res
 
-let make_matrix sx sy init =
+let makeMatrix sx sy init =
   let res = create sx [||] in
   for x = 0 to pred sx do
     unsafe_set res x (create sy init)
   done;
   res
 
-let create_matrix = make_matrix
+
 
 let copy a =
   let l = length a in if l = 0 then [||] else unsafe_sub a 0 l
@@ -59,18 +61,24 @@ let append a1 a2 =
 
 let sub a ofs len =
   if len < 0 || ofs > length a - len
-  then invalid_arg "Array.sub"
+  then 
+    (* invalid_arg  *)
+    [%assert "Array.sub"]
   else unsafe_sub a ofs len
 
 let fill a ofs len v =
   if ofs < 0 || len < 0 || ofs > length a - len
-  then invalid_arg "Array.fill"
+  then 
+    (* invalid_arg  *)
+    [%assert "Array.fill"]
   else for i = ofs to ofs + len - 1 do unsafe_set a i v done
 
 let blit a1 ofs1 a2 ofs2 len =
   if len < 0 || ofs1 < 0 || ofs1 > length a1 - len
              || ofs2 < 0 || ofs2 > length a2 - len
-  then invalid_arg "Array.blit"
+  then 
+    (* invalid_arg  *)
+    [%assert "Array.blit"]
   else unsafe_blit a1 ofs1 a2 ofs2 len
 
 let iter f a =
@@ -99,7 +107,7 @@ let mapi f a =
     r
   end
 
-let to_list a =
+let toList a =
   let rec tolist i res =
     if i < 0 then res else tolist (i - 1) (unsafe_get a i :: res) in
   tolist (length a - 1) []
@@ -110,7 +118,7 @@ let rec list_length accu = function
   | h::t -> list_length (succ accu) t
 ;;
 
-let of_list = function
+let ofList = function
     [] -> [||]
   | hd::tl as l ->
       let a = create (list_length 0 l) hd in
@@ -119,14 +127,14 @@ let of_list = function
         | hd::tl -> unsafe_set a i hd; fill (i+1) tl in
       fill 1 tl
 
-let fold_left f x a =
+let foldLeft f x a =
   let r = ref x in
   for i = 0 to length a - 1 do
     r := f !r (unsafe_get a i) [@bs]
   done;
   !r
 
-let fold_right f a x =
+let foldRight f a x =
   let r = ref x in
   for i = length a - 1 downto 0 do
     r := f (unsafe_get a i) !r [@bs]
@@ -184,7 +192,7 @@ let sort cmp a =
 ;;
 
 let cutoff = 5;;
-let stable_sort cmp a =
+let stableSort cmp a =
   let merge src1ofs src1len src2 src2ofs src2len dst dstofs =
     let src1r = src1ofs + src1len and src2r = src2ofs + src2len in
     let rec loop i1 s1 i2 s2 d =
@@ -236,4 +244,4 @@ let stable_sort cmp a =
   end;
 ;;
 
-let fast_sort = stable_sort;;
+let fastSort = stableSort;;

jscomp/others/bs_Array.mli

@@ -57,7 +57,7 @@ val init : int -> (int -> 'a [@bs]) -> 'a array
    If the return type of [f] is [float], then the maximum
    size is only [Sys.max_array_length / 2].*)
 
-val make_matrix : int -> int -> 'a -> 'a array array
+val makeMatrix : int -> int -> 'a -> 'a array array
 (** [Array.make_matrix dimx dimy e] returns a two-dimensional array
    (an array of arrays) with first dimension [dimx] and
    second dimension [dimy]. All the elements of this new matrix
@@ -109,10 +109,10 @@ val blit : 'a array -> int -> 'a array -> int -> int -> unit
    designate a valid subarray of [v1], or if [o2] and [len] do not
    designate a valid subarray of [v2]. *)
 
-val to_list : 'a array -> 'a list
+val toList : 'a array -> 'a list
 (** [Array.to_list a] returns the list of all the elements of [a]. *)
 
-val of_list : 'a list -> 'a array
+val ofList : 'a list -> 'a array
 (** [Array.of_list l] returns a fresh array containing the elements
    of [l]. *)
 
@@ -136,17 +136,17 @@ val mapi : (int -> 'a -> 'b [@bs]) -> 'a array -> 'b array
    function is applied to the index of the element as first argument,
    and the element itself as second argument. *)
 
-val fold_left : ('a -> 'b -> 'a [@bs]) -> 'a -> 'b array -> 'a
+val foldLeft : ('a -> 'b -> 'a [@bs]) -> 'a -> 'b array -> 'a
 (** [Array.fold_left f x a] computes
    [f (... (f (f x a.(0)) a.(1)) ...) a.(n-1)],
    where [n] is the length of the array [a]. *)
 
-val fold_right : ('b -> 'a -> 'a [@bs]) -> 'b array -> 'a -> 'a
+val foldRight : ('b -> 'a -> 'a [@bs]) -> 'b array -> 'a -> 'a
 (** [Array.fold_right f a x] computes
    [f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...))],
    where [n] is the length of the array [a]. *)
 
-external make_float: int -> float array = "caml_make_float_vect"
+external makeFloat: int -> float array = "caml_make_float_vect"
 (** [Array.make_float n] returns a fresh float array of length [n],
     with uninitialized data.
     @since 4.02 *)
@@ -180,7 +180,7 @@ val sort : ('a -> 'a -> int [@bs]) -> 'a array -> unit
 -   [cmp a.(i) a.(j)] >= 0 if and only if i >= j
 *)
 
-val stable_sort : ('a -> 'a -> int [@bs]) -> 'a array -> unit
+val stableSort : ('a -> 'a -> int [@bs]) -> 'a array -> unit
 (** Same as {!Array.sort}, but the sorting algorithm is stable (i.e.
    elements that compare equal are kept in their original order) and
    not guaranteed to run in constant heap space.
@@ -190,7 +190,7 @@ val stable_sort : ('a -> 'a -> int [@bs]) -> 'a array -> unit
    It is usually faster than the current implementation of {!Array.sort}.
 *)
 
-val fast_sort : ('a -> 'a -> int [@bs]) -> 'a array -> unit
+val fastSort : ('a -> 'a -> int [@bs]) -> 'a array -> unit
 (** Same as {!Array.sort} or {!Array.stable_sort}, whichever is faster
     on typical input.
 *)