API / Belt / MutableMapString

MutableMapString

key

```RES```type key = string
``````

t

```RES```type t<'a>
``````

make

```RES```let make: unit => t<'a>
``````

clear

```RES```let clear: t<'a> => unit
``````

isEmpty

```RES```let isEmpty: t<'a> => bool
``````

has

```RES```let has: (t<'a>, key) => bool
``````

cmpU

```RES```let cmpU: (t<'a>, t<'a>, (. 'a, 'a) => int) => int
``````

cmp

```RES```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.

eqU

```RES```let eqU: (t<'a>, t<'a>, (. 'a, 'a) => bool) => bool
``````

eq

```RES```let eq: (t<'a>, t<'a>, ('a, 'a) => bool) => bool
``````

`eq(m1, m2, cmp)`

forEachU

```RES```let forEachU: (t<'a>, (. key, 'a) => unit) => unit
``````

forEach

```RES```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.

reduceU

```RES```let reduceU: (t<'a>, 'b, (. 'b, key, 'a) => 'b) => 'b
``````

reduce

```RES```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.

everyU

```RES```let everyU: (t<'a>, (. key, 'a) => bool) => bool
``````

every

```RES```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.

someU

```RES```let someU: (t<'a>, (. key, 'a) => bool) => bool
``````

some

```RES```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.

size

```RES```let size: t<'a> => int
``````

toList

```RES```let toList: t<'a> => list<(key, 'a)>
``````

In increasing order

toArray

```RES```let toArray: t<'a> => array<(key, 'a)>
``````

fromArray

```RES```let fromArray: array<(key, 'a)> => t<'a>
``````

keysToArray

```RES```let keysToArray: t<'a> => array<key>
``````

valuesToArray

```RES```let valuesToArray: t<'a> => array<'a>
``````

minKey

```RES```let minKey: t<'a> => option<key>
``````

minKeyUndefined

```RES```let minKeyUndefined: t<'a> => Js.undefined<key>
``````

maxKey

```RES```let maxKey: t<'a> => option<key>
``````

maxKeyUndefined

```RES```let maxKeyUndefined: t<'a> => Js.undefined<key>
``````

minimum

```RES```let minimum: t<'a> => option<(key, 'a)>
``````

minUndefined

```RES```let minUndefined: t<'a> => Js.undefined<(key, 'a)>
``````

maximum

```RES```let maximum: t<'a> => option<(key, 'a)>
``````

maxUndefined

```RES```let maxUndefined: t<'a> => Js.undefined<(key, 'a)>
``````

get

```RES```let get: (t<'a>, key) => option<'a>
``````

getUndefined

```RES```let getUndefined: (t<'a>, key) => Js.undefined<'a>
``````

getWithDefault

```RES```let getWithDefault: (t<'a>, key, 'a) => 'a
``````

getExn

```RES```let getExn: (t<'a>, key) => 'a
``````

checkInvariantInternal

```RES```let checkInvariantInternal: t<'a> => unit
``````

Raise when invariant is not held.

remove

```RES```let remove: (t<'a>, key) => unit
``````

`remove(m, x)` do the in-place modification.

removeMany

```RES```let removeMany: (t<'a>, array<key>) => unit
``````

set

```RES```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.

updateU

```RES```let updateU: (t<'a>, key, (. option<'a>) => option<'a>) => unit
``````

update

```RES```let update: (t<'a>, key, option<'a> => option<'a>) => unit
``````

mapU

```RES```let mapU: (t<'a>, (. 'a) => 'b) => t<'b>
``````

map

```RES```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.

mapWithKeyU

```RES```let mapWithKeyU: (t<'a>, (. key, 'a) => 'b) => t<'b>
``````

mapWithKey

```RES```let mapWithKey: (t<'a>, (key, 'a) => 'b) => t<'b>
``````