rename bs to belt

Author: bobzhang

Diff for: jscomp/others/.depend

@@ -28,7 +28,7 @@ bs_SortArrayInt.cmj : bs_Array.cmj bs_SortArrayInt.cmi
 bs_SortArrayString.cmj : bs_Array.cmj bs_SortArrayString.cmi
 bs_Range.cmj : bs_Range.cmi
 bs_internalBucketsType.cmj : bs_Array.cmj bs_internalBucketsType.cmi
-bs_internalSetBuckets.cmj : bs_internalBucketsType.cmj bs_Array.cmj bs.cmj \
+bs_internalSetBuckets.cmj : bs_internalBucketsType.cmj bs_Array.cmj \
     bs_internalSetBuckets.cmi
 bs_internalBuckets.cmj : bs_internalBucketsType.cmj bs_Array.cmj \
     bs_internalBuckets.cmi

Diff for: jscomp/others/Makefile

@@ -2,7 +2,7 @@ include ../Makefile.shared
 
 COMPILER=../../lib/bsc.exe
 
-MAP_FILES= node bs
+MAP_FILES= node belt
 
 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 \

Diff for: jscomp/others/bs.ml renamed to jscomp/others/belt.ml

@@ -70,19 +70,19 @@
     {[
       type t = int * int 
       module I0 =
-        (val Bs.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
+        (val Belt.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
              match compare a0 b0 with
              | 0 -> compare a1 b1
              | c -> c 
            ))
-    let s0 = Bs.Set.make ~id:(module I0)
+    let s0 = Belt.Set.make ~id:(module I0)
     module I1 =
-      (val Bs.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
+      (val Belt.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
            match compare a1 b1 with
            | 0 -> compare a0 b0
            | c -> c 
          ))
-    let s1 = Bs.Set.make ~id:(module I1)
+    let s1 = Belt.Set.make ~id:(module I1)
     ]}
 
     Here the compiler would infer [s0] and [s1] having different type so that
@@ -98,25 +98,25 @@
     {b Collection Hierachy}
 
     In general, we provide a generic collection module, but also create specialized
-    modules for commonly used data type, take {i Bs.Set} for example
+    modules for commonly used data type, take {i Belt.Set} for example
 
     {[
-      Bs.Set
-      Bs.Set.Int
-      Bs.Set.String
+      Belt.Set
+      Belt.Set.Int
+      Belt.Set.String
     ]}
 
-    The specialized module {i Bs.Set.Int}, {i Bs.Set.String} is in general more
+    The specialized module {i Belt.Set.Int}, {i Belt.Set.String} is in general more
     efficient.
 
-    Currently, both {i Bs_Set} and {i Bs.Set} are accessible to users for some
+    Currently, both {i Bs_Set} and {i Belt.Set} are accessible to users for some
     technical rasons,
-    we {b strongly recommend} users stick to qualified import, {i Bs.Sort}, we may hide
+    we {b strongly recommend} users stick to qualified import, {i Belt.Sort}, we may hide
     the internal, {i i.e}, {i Bs_Set} in the future
     
 *)
 
-(** {!Bs.Id}
+(** {!Belt.Id}
 
     Provide utiliites to create identified comparators or hashes for 
     data structures used below. 
@@ -127,106 +127,106 @@
 *)
 module Id = Bs_Id
 
-(** {!Bs.Array}
+(** {!Belt.Array}
 
     {b mutable array}: Utililites functions
 *)
 module Array = Bs_Array
 
-(** {!Bs.SortArray}
+(** {!Belt.SortArray}
     
     The toplevel provides some generic sort related utililties.
     
     It also has two specialized inner modules
-    {!Bs.SortArray.Int} and {!Bs.SortArray.String}
+    {!Belt.SortArray.Int} and {!Belt.SortArray.String}
 *)
 module SortArray = Bs_SortArray
 
-(** {!Bs.MutableQueue}
+(** {!Belt.MutableQueue}
     
     An FIFO(first in first out) queue data structure
 *)
 module MutableQueue = Bs_MutableQueue
 
-(** {!Bs.MutableStack}
+(** {!Belt.MutableStack}
     
     An FILO(first in last out) stack data structure
 *)
 module MutableStack = Bs_MutableStack 
 
-(** {!Bs.List}
+(** {!Belt.List}
     
     Utilities for List data type
 *)
 module List = Bs_List
 
-(** {!Bs.Range}
+(** {!Belt.Range}
     
     Utilities for a closed range [(from, start)]
 *)
 module Range = Bs_Range
 
-(** {!Bs.Set}
+(** {!Belt.Set}
 
     The toplevel provides generic {b immutable} set operations.
 
     It also has three specialized inner modules
-    {!Bs.Set.Int} and {!Bs.Set.String}
-    {!Bs.Set.Dict}: This module separate date from function
+    {!Belt.Set.Int} and {!Belt.Set.String}
+    {!Belt.Set.Dict}: This module separate date from function
     which  is more verbbose but slightly more efficient
 
 *)
 module Set = Bs_Set
 
 
-(** {!Bs.Map},
+(** {!Belt.Map},
 
     The toplevel provides generic {b immutable} map operations.
     
     It also has three specialized inner modules
-    {!Bs.Map.Int} and {!Bs.Map.String}
-    {!Bs.Map.Dict}: This module separate date from function
+    {!Belt.Map.Int} and {!Belt.Map.String}
+    {!Belt.Map.Dict}: This module separate date from function
     which  is more verbbose but slightly more efficient
 *)    
 module Map = Bs_Map
 
 
-(** {!Bs.MutableSet}
+(** {!Belt.MutableSet}
     
     The toplevel provides generic {b mutable} set operations.
     
     It also has two specialized inner modules
-    {!Bs.MutableSet.Int} and {!Bs.MutableSet.String}
+    {!Belt.MutableSet.Int} and {!Belt.MutableSet.String}
 *)
 module MutableSet = Bs_MutableSet
 
-(** {!Bs.MutableMap}
+(** {!Belt.MutableMap}
     
     The toplevel provides generic {b mutable} map operations.
     
     It also has two specialized inner modules
-    {!Bs.MutableMap.Int} and {!Bs.MutableMap.String}
+    {!Belt.MutableMap.Int} and {!Belt.MutableMap.String}
 
 *)
 module MutableMap = Bs_MutableMap
 
 
-(** {!Bs.HashSet}
+(** {!Belt.HashSet}
     
     The toplevel provides generic {b mutable} hash set operations.
     
     It also has two specialized inner modules
-    {!Bs.HashSet.Int} and {!Bs.HashSet.String}
+    {!Belt.HashSet.Int} and {!Belt.HashSet.String}
 *)
 module HashSet = Bs_HashSet
 
 
-(** {!Bs.HashMap}
+(** {!Belt.HashMap}
     
     The toplevel provides generic {b mutable} hash map operations.
     
     It also has two specialized inner modules
-    {!Bs.HashMap.Int} and {!Bs.HashMap.String}
+    {!Belt.HashMap.Int} and {!Belt.HashMap.String}
 *)
 module HashMap = Bs_HashMap
 

Diff for: jscomp/others/bs_Array.mli

@@ -13,7 +13,7 @@
 (* Adapted significantly by Authors of BuckleScript *)
 
 
-(** {!Bs.Array}    
+(** {!Belt.Array}    
     Utililites for Array functions 
 *)
 

Diff for: jscomp/others/bs_HashMap.mli

@@ -32,13 +32,13 @@
     {[
       type t = int 
       module I0 =
-        (val Bs.Id.hashableU
+        (val Belt.Id.hashableU
             ~hash:(fun[\@bs] (a : t)  -> a & 0xff_ff)
             ~eq:(fun[\@bs] a b -> a = b)
         )
       let s0 : (_, string,_) t = make ~hintSize:40 ~id:(module I0)
       module I1 =
-        (val Bs.Id.hashableU
+        (val Belt.Id.hashableU
             ~hash:(fun[\@bs] (a : t)  -> a & 0xff)
             ~eq:(fun[\@bs] a b -> a = b)
         )

Diff for: jscomp/others/bs_HashSet.mli

@@ -32,13 +32,13 @@
     {[
       type t = int 
       module I0 =
-        (val Bs.Id.hashableU
+        (val Belt.Id.hashableU
             ~hash:(fun[\@bs] (a : t)  -> a & 0xff_ff)
             ~eq:(fun[\@bs] a b -> a = b)
         )
       let s0 = make ~id:(module I0) ~hintSize:40
       module I1 =
-        (val Bs.Id.hashableU
+        (val Belt.Id.hashableU
             ~hash:(fun[\@bs] (a : t)  -> a & 0xff)
             ~eq:(fun[\@bs] a b -> a = b)
         )

Diff for: jscomp/others/bs_HashSetInt.mli

@@ -24,12 +24,12 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
 
-(** This module is {!Bs.HashSet} specialized with key type to be a primitive type.
+(** This module is {!Belt.HashSet} specialized with key type to be a primitive type.
 
-    It is more efficient in general, the  API is the same with {!Bs.HashSet} except its key type is fixed,
+    It is more efficient in general, the  API is the same with {!Belt.HashSet} except its key type is fixed,
     and identity is not needed(using the built-in one)
 
-    {b See} {!Bs.HashSet}
+    {b See} {!Belt.HashSet}
 *)
 
 

Diff for: jscomp/others/bs_HashSetString.mli

@@ -24,12 +24,12 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
 
-(** This module is {!Bs.HashSet} specialized with key type to be a primitive type.
+(** This module is {!Belt.HashSet} specialized with key type to be a primitive type.
 
-    It is more efficient in general, the  API is the same with {!Bs.HashSet} except its key type is fixed,
+    It is more efficient in general, the  API is the same with {!Belt.HashSet} except its key type is fixed,
     and identity is not needed(using the built-in one)
 
-    {b See} {!Bs.HashSet}
+    {b See} {!Belt.HashSet}
 *)
 
 

Diff for: jscomp/others/bs_Id.mli

@@ -24,7 +24,7 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
 
 
-(** {!Bs.Id}
+(** {!Belt.Id}
     
     Provide utiliites to create identified comparators or hashes for 
     data structures used below. 

Diff for: jscomp/others/bs_List.mli

@@ -22,7 +22,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
 
-(** {!Bs.List}
+(** {!Belt.List}
     
     Utilities for List data type
 *)

Diff for: jscomp/others/bs_Map.mli

@@ -25,14 +25,14 @@
    {[
      type t = int * int 
       module I0 =
-        (val Bs.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
+        (val Belt.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
              match Pervasives.compare a0 b0 with
              | 0 -> Pervasives.compare a1 b1
              | c -> c 
            ))
     let s0 : (_, string, _) t = make ~id:(module I0) (* value is of type string *)
     module I1 =
-      (val Bs.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
+      (val Belt.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
            match compare a1 b1 with
            | 0 -> compare a0 b0
            | c -> c 

Diff for: jscomp/others/bs_MutableMap.mli

@@ -36,14 +36,14 @@
    {[
      type t = int * int 
       module I0 =
-        (val Bs.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
+        (val Belt.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
              match Pervasives.compare a0 b0 with
              | 0 -> Pervasives.compare a1 b1
              | c -> c 
            ))
     let s0 : (_, string,_) t = make ~id:(module I0)
     module I1 =
-      (val Bs.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
+      (val Belt.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
            match compare a1 b1 with
            | 0 -> compare a0 b0
            | c -> c 

Diff for: jscomp/others/bs_MutableQueue.ml

@@ -71,7 +71,7 @@ let peekUndefined q =
 
 let peekExn q =
   match Js.nullToOption (first q ) with
-  | None -> [%assert "Bs.Queue.Empty"]
+  | None -> [%assert "Belt.Queue.Empty"]
   | Some v -> content v
 
 let pop q =
@@ -92,7 +92,7 @@ let pop q =
 
 let popExn q =
   match Js.nullToOption (first q ) with
-  | None -> [%assert "Bs.Queue.Empty"]
+  | None -> [%assert "Empty"]
   | Some x  ->
     let next = next x in 
     if Js.Null.test next then 

Diff for: jscomp/others/bs_MutableSet.mli

@@ -36,14 +36,14 @@
    {[
      type t = int * int 
       module I0 =
-        (val Bs.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
+        (val Belt.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
              match Pervasives.compare a0 b0 with
              | 0 -> Pervasives.compare a1 b1
              | c -> c 
            ))
     let s0 = make ~id:(module I0)
     module I1 =
-      (val Bs.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
+      (val Belt.Id.comparableU ~cmp:(fun[\@bs] ((a0,a1) : t) ((b0,b1) : t) ->
            match compare a1 b1 with
            | 0 -> compare a0 b0
            | c -> c 

Diff for: jscomp/others/bs_MutableSetInt.ml

@@ -23,7 +23,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
 
-(** This module is {!Bs.MutableSet} specialized with key type to be a primitive type.
+(** This module is {!Belt.MutableSet} specialized with key type to be a primitive type.
     It is more efficient in general, the  API is the same with {!Bs_MutableSet} except its key type is fixed,
     and identity is not needed(using the built-in one) 
 *)

Diff for: jscomp/others/bs_MutableSetInt.mli

@@ -23,12 +23,12 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
 
-(** This module is {!Bs.MutableSet} specialized with key type to be a primitive type.
+(** This module is {!Belt.MutableSet} specialized with key type to be a primitive type.
 
-    It is more efficient in general, the  API is the same with {!Bs.MutableSet} except its key type is fixed,
+    It is more efficient in general, the  API is the same with {!Belt.MutableSet} except its key type is fixed,
     and identity is not needed(using the built-in one)
 
-    {b See} {!Bs.MutableSet}
+    {b See} {!Belt.MutableSet}
 *)
 
 

Diff for: jscomp/others/bs_MutableSetString.ml

@@ -23,7 +23,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
 
-(** This module is {!Bs.MutableSet} specialized with key type to be a primitive type.
+(** This module is {!Belt.MutableSet} specialized with key type to be a primitive type.
     It is more efficient in general, the  API is the same with {!Bs_MutableSet} except its key type is fixed,
     and identity is not needed(using the built-in one) 
 *)