API / Belt / MapInt

# MapInt

Specalized when key type is `int`, more efficient than the generic type, its compare behavior is fixed using the built-in comparison

``````type key = int;
``````
``````type t('value);
``````

The type of maps from type `key` to type `'value`.

``````let empty: t('v);
``````
``````let isEmpty: t('v) => bool;
``````
``````let has: (t('v), key) => bool;
``````
``````let cmpU: (t('v), t('v), [@bs] (('v, 'v) => int)) => int;
``````
``````let cmp: (t('v), t('v), ('v, 'v) => int) => int;
``````
``````let eqU: (t('v), t('v), [@bs] (('v, 'v) => bool)) => bool;
``````
``````let eq: (t('v), t('v), ('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.

``````let findFirstByU: (t('v), [@bs] ((key, 'v) => bool)) => option((key, 'v));
``````
``````let findFirstBy: (t('v), (key, 'v) => bool) => option((key, 'v));
``````

`findFirstBy(m, p)` uses function `f` to find the first key value pair to match predicate `p`.

```RE```let s0 = Belt.Map.Int.fromArray([|(4, "4"), (1, "1"), (2, "2"), (3, "3")|]);

Belt.Map.Int.findFirstBy(s0, (k, v) => k == 4) == Some((4, "4"));
``````
``````let forEachU: (t('v), [@bs] ((key, 'v) => unit)) => unit;
``````
``````let forEach: (t('v), (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.

``````let reduceU: (t('v), 'v2, [@bs] (('v2, key, 'v) => 'v2)) => 'v2;
``````
``````let reduce: (t('v), '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.

``````let everyU: (t('v), [@bs] ((key, 'v) => bool)) => bool;
``````
``````let every: (t('v), (key, 'v) => bool) => bool;
``````

`every(m, p)` checks if all the bindings of the map satisfy the predicate `p`. Order unspecified

``````let someU: (t('v), [@bs] ((key, 'v) => bool)) => bool;
``````
``````let some: (t('v), (key, 'v) => bool) => bool;
``````

`some(m, p)` checks if at least one binding of the map satisfy the predicate `p`. Order unspecified

``````let size: t('v) => int;
``````
``````let toList: t('v) => list((key, 'v));
``````

In increasing order.

``````let toArray: t('v) => array((key, 'v));
``````
``````let fromArray: array((key, 'v)) => t('v);
``````
``````let keysToArray: t('v) => array(key);
``````
``````let valuesToArray: t('v) => array('v);
``````
``````let minKey: t('a) => option(key);
``````
``````let minKeyUndefined: t('a) => Js.undefined(key);
``````
``````let maxKey: t('a) => option(key);
``````
``````let maxKeyUndefined: t('a) => Js.undefined(key);
``````
``````let minimum: t('v) => option((key, 'v));
``````
``````let minUndefined: t('v) => Js.undefined((key, 'v));
``````
``````let maximum: t('v) => option((key, 'v));
``````
``````let maxUndefined: t('v) => Js.undefined((key, 'v));
``````
``````let get: (t('v), key) => option('v);
``````
``````let getUndefined: (t('v), key) => Js.undefined('v);
``````
``````let getWithDefault: (t('v), key, 'v) => 'v;
``````
``````let getExn: (t('v), key) => 'v;
``````
``````let checkInvariantInternal: t('a) => unit;
``````

raise when invariant is not held

``````let remove: (t('v), key) => t('v);
``````

`remove(m, x)` returns a map containing the same bindings as `m`, except for `x` which is unbound in the returned map.

``````let removeMany: (t('v), array(key)) => t('v);
``````
``````let set: (t('v), key, 'v) => t('v);
``````

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

``````let updateU: (t('v), key, [@bs] (option('v) => option('v))) => t('v);
``````
``````let update: (t('v), key, option('v) => option('v)) => t('v);
``````
``````let mergeU: (t('v), t('v2), [@bs] ((key, option('v), option('v2)) => option('c))) => t('c);
``````
``````let merge: (t('v), t('v2), (key, option('v), option('v2)) => option('c)) => t('c);
``````

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

``````let mergeMany: (t('v), array((key, 'v))) => t('v);
``````
``````let keepU: (t('v), [@bs] ((key, 'v) => bool)) => t('v);
``````
``````let keep: (t('v), (key, 'v) => bool) => t('v);
``````
``````let partitionU: (t('v), [@bs] ((key, 'v) => bool)) => (t('v), t('v));
``````
``````let partition: (t('v), (key, 'v) => bool) => (t('v), t('v));
``````

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

``````let split: (key, t('v)) => (t('v), option('v), t('v));
``````

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

``````let mapU: (t('v), [@bs] ('v => 'v2)) => t('v2);
``````
``````let map: (t('v), 'v => 'v2) => t('v2);
``````

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

``````let mapWithKeyU: (t('v), [@bs] ((key, 'v) => 'v2)) => t('v2);
``````
``````let mapWithKey: (t('v), (key, 'v) => 'v2) => t('v2);
``````