Sync docs for belt_MutableMapString.mli

Author: BartSchuurmans

jscomp/others/belt_MutableMapString.mli

@@ -25,82 +25,246 @@
 
 # 26 "others/mapm.cppo.mli"
 type key = string
+(** ```res prelude
+    type key = string
+    ```
+*)
+
 # 32 "others/mapm.cppo.mli"
 type 'a t
+(** ```res prelude
+    type t<'a>
+    ```
+*)
 
 
 val make: unit -> 'a t
+(** ```res sig
+    let make: unit => t<'a>
+    ```
+*)
+
 val clear: 'a t -> unit
+(** ```res sig
+    let clear: t<'a> => unit
+    ```
+*)
+
 val isEmpty: 'a t -> bool
+(** ```res sig
+    let isEmpty: t<'a> => bool
+    ```
+*)
 
 val has:  'a t -> key -> bool
+(** ```res sig
+    let has: (t<'a>, key) => bool
+    ```
+*)
 
 val cmpU:  'a t -> 'a t -> ('a -> 'a -> int [@bs]) -> int
+(** ```res sig
+    let cmpU: (t<'a>, t<'a>, (. 'a, 'a) => int) => int
+    ```
+*)
+
 val cmp:  'a t -> 'a t -> ('a -> 'a -> int) -> int
-(** `cmp m1 m2 cmp`
-  First compare by size, if size is the same,
-  compare by key, value pair
+(** ```res sig
+    let cmp: (t<'a>, t<'a>, ('a, 'a) => int) => int
+    ```
+
+    `cmp(m1, m2, cmp)` First compare by size, if size is the same, compare by key, value pair.
 *)
 
 val eqU: 'a t -> 'a t -> ('a -> 'a -> bool [@bs]) -> bool
+(** ```res sig
+    let eqU: (t<'a>, t<'a>, (. 'a, 'a) => bool) => bool
+    ```
+*)
+
 val eq: 'a t -> 'a t -> ('a -> 'a -> bool ) -> bool
-(** `eq m1 m2 cmp` *)
+(** ```res sig
+    let eq: (t<'a>, t<'a>, ('a, 'a) => bool) => bool
+    ```
+
+    `eq(m1, m2, cmp)`
+*)
 
 val forEachU: 'a t -> (key -> 'a -> unit [@bs]) ->  unit
+(** ```res sig
+    let forEachU: (t<'a>, (. key, 'a) => unit) => unit
+    ```
+*)
+
 val forEach: 'a t -> (key -> 'a -> 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 application order of `f`  is in increasing order. *)
+(** ```res sig
+    let forEach: (t<'a>, (key, 'a) => 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 application order of `f` is in increasing order.
+*)
 
 val reduceU:  'a t -> 'b -> ('b -> key -> 'a -> 'b [@bs]) -> 'b
+(** ```res sig
+    let reduceU: (t<'a>, 'b, (. 'b, key, 'a) => 'b) => 'b
+    ```
+*)
+
 val reduce:  'a t -> 'b -> ('b -> key -> 'a -> 'b ) -> '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. *)
+(** ```res sig
+    let reduce: (t<'a>, 'b, ('b, key, 'a) => 'b) => '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.
+*)
 
 val everyU:  'a t -> (key -> 'a -> bool [@bs]) -> bool
+(** ```res sig
+    let everyU: (t<'a>, (. key, 'a) => bool) => bool
+    ```
+*)
+
 val every:  'a t -> (key -> 'a -> bool) -> bool
-(** `every m p` checks if all the bindings of the map
-  satisfy the predicate `p`.
-  The application order of `p` is unspecified.
+(** ```res sig
+    let every: (t<'a>, (key, 'a) => bool) => bool
+    ```
+
+    `every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. The application order of `p` is unspecified.
 *)
 
 val someU:  'a t -> (key -> 'a -> bool [@bs]) -> bool
+(** ```res sig
+    let someU: (t<'a>, (. key, 'a) => bool) => bool
+    ```
+*)
+
 val some:  'a t -> (key -> 'a -> bool) -> bool
-(** `some m p` checks if at least one binding of the map
-  satisfy the predicate `p`.
-  The application order of `p` is unspecified.
+(** ```res sig
+    let some: (t<'a>, (key, 'a) => bool) => bool
+    ```
+
+    `some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. The application order of `p` is unspecified.
 *)
 
 
 
 
 val size: 'a t -> int
+(** ```res sig
+    let size: t<'a> => int
+    ```
+*)
+
 val toList: 'a t -> (key * 'a) list
-(** In increasing order *)
+(** ```res sig
+    let toList: t<'a> => list<(key, 'a)>
+    ```
+
+    In increasing order
+*)
 
 val toArray: 'a t -> (key * 'a) array
-(** In increasing order *)
+(** ```res sig
+    let toArray: t<'a> => array<(key, 'a)>
+    ```
+*)
 
 val fromArray: (key * 'a) array -> 'a t
+(** ```res sig
+    let fromArray: array<(key, 'a)> => t<'a>
+    ```
+*)
+
 val keysToArray: 'a t -> key array
+(** ```res sig
+    let keysToArray: t<'a> => array<key>
+    ```
+*)
+
 val valuesToArray: 'a t -> 'a array
+(** ```res sig
+    let valuesToArray: t<'a> => array<'a>
+    ```
+*)
+
 val minKey: _ t -> key option
+(** ```res sig
+    let minKey: t<'a> => option<key>
+    ```
+*)
+
 val minKeyUndefined: _ t -> key Js.undefined
+(** ```res sig
+    let minKeyUndefined: t<'a> => Js.undefined<key>
+    ```
+*)
+
 val maxKey: _ t -> key option
+(** ```res sig
+    let maxKey: t<'a> => option<key>
+    ```
+*)
+
 val maxKeyUndefined: _ t -> key Js.undefined
+(** ```res sig
+    let maxKeyUndefined: t<'a> => Js.undefined<key>
+    ```
+*)
+
 val minimum: 'a t -> (key * 'a) option
+(** ```res sig
+    let minimum: t<'a> => option<(key, 'a)>
+    ```
+*)
+
 val minUndefined: 'a t -> (key * 'a) Js.undefined
+(** ```res sig
+    let minUndefined: t<'a> => Js.undefined<(key, 'a)>
+    ```
+*)
+
 val maximum: 'a t -> (key * 'a) option
+(** ```res sig
+    let maximum: t<'a> => option<(key, 'a)>
+    ```
+*)
+
 val maxUndefined: 'a t -> (key * 'a) Js.undefined
+(** ```res sig
+    let maxUndefined: t<'a> => Js.undefined<(key, 'a)>
+    ```
+*)
+
 val get: 'a t ->  key -> 'a option
+(** ```res sig
+    let get: (t<'a>, key) => option<'a>
+    ```
+*)
+
 val getUndefined: 'a t -> key -> 'a Js.undefined
+(** ```res sig
+    let getUndefined: (t<'a>, key) => Js.undefined<'a>
+    ```
+*)
+
 val getWithDefault:  'a t -> key -> 'a  -> 'a
+(** ```res sig
+    let getWithDefault: (t<'a>, key, 'a) => 'a
+    ```
+*)
+
 val getExn: 'a t -> key -> 'a
+(** ```res sig
+    let getExn: (t<'a>, key) => 'a
+    ```
+*)
+
 val checkInvariantInternal: _ t -> unit
-(**
-  **raise** when invariant is not held
+(** ```res sig
+    let checkInvariantInternal: t<'a> => unit
+    ```
+
+    Raise when invariant is not held.
 *)
 
 
@@ -110,26 +274,62 @@ val checkInvariantInternal: _ t -> unit
 (*TODO: add functional `merge, partition, keep, split`*)
 
 val remove: 'a t -> key -> unit
-(** `remove m x` do the in-place modification *)
+(** ```res sig
+    let remove: (t<'a>, key) => unit
+    ```
+
+    `remove(m, x)` do the in-place modification.
+*)
 
 val removeMany: 'a t -> key array -> unit
+(** ```res sig
+    let removeMany: (t<'a>, array<key>) => unit
+    ```
+*)
 
 val set: 'a t -> key -> 'a -> unit
-(** `set m x y` do the in-place modification, return
-  `m` for chaining. If `x` was already bound
-  in `m`, its previous binding disappears. *)
+(** ```res sig
+    let set: (t<'a>, key, 'a) => unit
+    ```
+
+    `set(m, x, y)` do the in-place modification, return `m` for chaining. If `x` was already bound in `m`, its previous binding disappears.
+*)
 
 val updateU: 'a t -> key -> ('a option -> 'a option [@bs]) -> unit
+(** ```res sig
+    let updateU: (t<'a>, key, (. option<'a>) => option<'a>) => unit
+    ```
+*)
+
 val update: 'a t -> key -> ('a option -> 'a option) -> unit
+(** ```res sig
+    let update: (t<'a>, key, option<'a> => option<'a>) => unit
+    ```
+*)
 
 
 val mapU: 'a t -> ('a -> 'b [@bs]) ->  'b t
+(** ```res sig
+    let mapU: (t<'a>, (. 'a) => 'b) => t<'b>
+    ```
+*)
+
 val map: 'a t -> ('a -> 'b) ->  'b 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. *)
+(** ```res sig
+    let map: (t<'a>, 'a => 'b) => t<'b>
+    ```
+
+    `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: 'a t -> (key -> 'a -> 'b [@bs]) -> 'b t
+(** ```res sig
+    let mapWithKeyU: (t<'a>, (. key, 'a) => 'b) => t<'b>
+    ```
+*)
+
 val mapWithKey: 'a t -> (key -> 'a -> 'b) -> 'b t
+(** ```res sig
+    let mapWithKey: (t<'a>, (key, 'a) => 'b) => t<'b>
+    ```
+*)