Sync docs for belt_MapString.mli

Author: BartSchuurmans

jscomp/others/belt_MapString.mli

@@ -1,3 +1,13 @@
+(** Specalized when key type is `string`, more efficient than the generic type,
+    its compare behavior is fixed using the built-in comparison
+*)
+
+(*  ```res prelude
+    type key = string
+    type t<'value>
+    ```
+*)
+
 # 2 "others/map.cppo.mli"
 type key = string
 # 8 "others/map.cppo.mli"
@@ -15,50 +25,43 @@ val cmp: 'v t -> 'v t -> ('v -> 'v -> int) -> int
 
 val eqU: 'v t -> 'v t -> ('v -> 'v -> bool [@bs]) -> bool
 val eq: 'v t -> 'v t -> ('v -> 'v -> bool) -> bool
-(**
-  `eq m1 m2` tests whether the maps `m1` and `m2` are
-  equal, that is, contain equal keys and associate them with
-  equal data.
-*)
+(** `eq(m1, m2)` tests whether the maps `m1` and `m2` are equal, that is,
+    contain equal keys and associate them with equal data. *)
 
 val findFirstByU : 'v t -> (key -> 'v -> bool [@bs]) -> (key * 'v) option
 val findFirstBy : 'v t -> (key -> 'v -> bool) -> (key * 'v) option
-(**
-  `findFirstBy m p` uses funcion `f` to find the first key value pair
-  to match predicate `p`.
-
-  ```
-  let s0 = fromArray ~id:(module IntCmp) [|4,"4";1,"1";2,"2,"3""|];;
-  findFirstBy s0 (fun k v -> k = 4 ) = option (4, "4");;
-  ```
+(** `findFirstBy(m, p)` uses function `f` to find the first key value pair to
+    match predicate `p`.
+
+    ```res example
+    let s0 = Belt.Map.String.fromArray([("4", 4), ("1", 1), ("2", 2), ("3", 3)])
+
+    Belt.Map.String.findFirstBy(s0, (k, _) => k == "4") == Some(("4", 4))
+    ```
 *)
 
 val forEachU: 'v t -> (key -> 'v -> unit [@bs]) -> unit
 val forEach: 'v t -> (key -> 'v -> unit) -> unit
-(**
-  `forEach m f` applies `f` to all bindings in map `m`.
-  `f` receives the key as first argument, and the associated value
-  as second argument. The bindings are passed to `f` in increasing
-  order with respect to the ordering over the type of the keys.
-*)
+(** `forEach(m, f)` applies `f` to all bindings in map `m`. `f` receives the
+    key as first argument, and the associated value as second argument. The
+    bindings are passed to `f` in increasing order with respect to the ordering
+    over the type of the keys. *)
 
 val reduceU: 'v t -> 'v2 -> ('v2 -> key -> 'v -> 'v2 [@bs]) -> 'v2
 val reduce: 'v t -> 'v2 -> ('v2 -> key -> 'v -> 'v2) -> 'v2
-(**
-  `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.
-*)
+(** `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. *)
 
 val everyU: 'v t -> (key -> 'v -> bool [@bs]) -> bool
 val every: 'v t -> (key -> 'v -> bool) -> bool
-(** `every m p` checks if all the bindings of the map
-    satisfy the predicate `p`. Order unspecified *)
+(** `every(m, p)` checks if all the bindings of the map satisfy the predicate
+    `p`. Order unspecified *)
 
 val someU: 'v t -> (key -> 'v -> bool [@bs]) -> bool
 val some: 'v t -> (key -> 'v -> bool) -> bool
-(** `some m p` checks if at least one binding of the map
-    satisfy the predicate `p`. Order unspecified *)
+(** `some(m, p)` checks if at least one binding of the map satisfy the
+    predicate `p`. Order unspecified *)
 
 val size: 'v t -> int
 
@@ -99,22 +102,18 @@ val getWithDefault: 'v t -> key -> 'v -> 'v
 val getExn: 'v t -> key -> 'v
 
 val checkInvariantInternal: _ t -> unit
-(**
-  **raise** when invariant is not held
-*)
+(** **raise** when invariant is not held *)
 
 val remove: 'v t -> key -> 'v t
-(** `remove m x` returns a map containing the same bindings as
-    `m`, except for `x` which is unbound in the returned map. *)
+(** `remove(m, x)` returns a map containing the same bindings as `m`, except
+    for `x` which is unbound in the returned map. *)
 
 val removeMany: 'v t -> key array -> 'v t
 
 val set: 'v t -> key -> 'v -> 'v t
-(**
-  `set m x y` returns a map containing the same bindings as
-  `m`, plus a binding of `x` to `y`. If `x` was already bound
-  in `m`, its previous binding disappears.
-*)
+(** `set(m, x, y)` returns a map containing the same bindings as `m`, plus a
+    binding of `x` to `y`. If `x` was already bound in `m`, its previous
+    binding disappears. *)
 
 val updateU: 'v t -> key -> ('v option -> 'v option [@bs]) -> 'v t
 val update: 'v t -> key -> ('v option -> 'v option) -> 'v t
@@ -127,11 +126,9 @@ val merge:
   'v t -> 'v2 t ->
   (key -> 'v option -> 'v2 option -> 'c option) ->
   'c t
-(**
-  `merge m1 m2 f` computes a map whose keys is a subset of keys of `m1`
-  and of `m2`. The presence of each such binding, and the corresponding
-  value, is determined with the function `f`.
-*)
+(** `merge(m1, m2, f)` computes a map whose keys is a subset of keys of `m1`
+    and of `m2`. The presence of each such binding, and the corresponding
+    value, is determined with the function `f`. *)
 
 val mergeMany: 'v t -> (key * 'v) array -> 'v t
 
@@ -144,8 +141,8 @@ val keep:
   'v t ->
   (key -> 'v -> bool) ->
   'v t
-(** `keep m p` returns the map with all the bindings in `m`
-    that satisfy predicate `p`. *)
+(** `keep(m, p)` returns the map with all the bindings in `m` that satisfy
+    predicate `p`. *)
 
 val partitionU:
   'v t ->
@@ -155,33 +152,23 @@ val partition:
   'v t ->
   (key -> 'v -> bool) ->
   'v t * 'v t
-(**
-  `partition m p` returns a pair of maps `(m1, m2)`, where
-  `m1` contains all the bindings of `s` that satisfy the
-  predicate `p`, and `m2` is the map with all the bindings of
-  `s` that do not satisfy `p`.
-*)
+(** `partition(m, p)` returns a pair of maps `(m1, m2)`, where `m1` contains
+    all the bindings of `s` that satisfy the predicate `p`, and `m2` is the map
+    with all the bindings of s that do not satisfy `p`. *)
 
 val split: key -> 'v t -> 'v t * 'v option * 'v t
-(**
-  `split x m` returns a triple `(l, data, r)`, where
-  `l` is the map with all the bindings of `m` whose key
-  is strictly less than `x`;
-  `r` is the map with all the bindings of `m` whose key
-  is strictly greater than `x`;
-  `data` is `None` if `m` contains no binding for `x`,
-  or `Some v` if `m` binds `v` to `x`.
-*)
+(** `split(x, m)` returns a triple `(l, data, r)`, where `l` is the map with
+    all the bindings of `m` whose key is strictly less than `x`; `r` is the map
+    with all the bindings of m whose key is strictly greater than `x`; `data`
+    is `None` if `m` contains no binding for `x`, or `Some(v)` if `m` binds `v`
+    to `x`. *)
 
 val mapU: 'v t -> ('v -> 'v2 [@bs]) -> 'v2 t
 val map: 'v t -> ('v -> 'v2) -> 'v2 t
-(**
-  `map m f` returns a map with same domain as `m`, where the
-  associated value `a` of all bindings of `m` has been
-  replaced by the result of the application of `f` to `a`.
-  The bindings are passed to `f` in increasing order
-  with respect to the ordering over the type of the keys.
-*)
+(** `map(m, f)` returns a map with same domain as `m`, where the associated
+    value `a` of all bindings of `m` has been replaced by the result of the
+    application of `f` to `a`. The bindings are passed to `f` in increasing
+    order with respect to the ordering over the type of the keys. *)
 
 val mapWithKeyU: 'v t -> (key -> 'v -> 'v2 [@bs]) -> 'v2 t
 val mapWithKey: 'v t -> (key -> 'v -> 'v2) -> 'v2 t