MutableMap

Same as Belt.Map, but mutable.

type t('k, 'v, 'id);

type id('key, 'id) = Belt_Id.comparable('key, 'id);

let make: (~id: id('k, 'id)) => t('k, 'a, 'id);

let clear: t('a, 'b, 'c) => unit;

let isEmpty: t('a, 'b, 'c) => bool;

let has: (t('k, 'a, 'b), 'k) => bool;

let cmpU: (t('k, 'a, 'id), t('k, 'a, 'id), [@bs] (('a, 'a) => int)) => int;

let cmp: (t('k, 'a, 'id), t('k, 'a, 'id), ('a, 'a) => int) => int;

cmp(m1, m2, cmp) First compare by size, if size is the same, compare by key, value pair.

let eqU: (t('k, 'a, 'id), t('k, 'a, 'id), [@bs] (('a, 'a) => bool)) => bool;

let eq: (t('k, 'a, 'id), t('k, 'a, 'id), ('a, 'a) => bool) => bool;

eq(m1, m2, eqf) tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. eqf is the equality predicate used to compare the data associated with the keys.

let forEachU: (t('k, 'a, 'id), [@bs] (('k, 'a) => unit)) => unit;

let forEach: (t('k, 'a, 'id), ('k, 'a) => unit) => unit;

forEach(m, f) applies f to all bindings in map m. f receives the 'k 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('k, 'a, 'id), 'b, [@bs] (('b, 'k, 'a) => 'b)) => 'b;

let reduce: (t('k, 'a, 'id), 'b, ('b, 'k, 'a) => 'b) => 'b;

reduce(m, a, f), computes(f(kN, dN) ... (f(k1, d1, a))...), wherek1 ... kNare the keys of all bindings inm(in increasing order), andd1 ... dN` are the associated data.

let everyU: (t('k, 'a, 'id), [@bs] (('k, 'a) => bool)) => bool;

let every: (t('k, 'a, 'id), ('k, 'a) => bool) => bool;

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

let someU: (t('k, 'a, 'id), [@bs] (('k, 'a) => bool)) => bool;

let some: (t('k, 'a, 'id), ('k, 'a) => bool) => bool;

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

let size: t('k, 'a, 'id) => int;

let toList: t('k, 'a, 'id) => list(('k, 'a));

In increasing order.

let toArray: t('k, 'a, 'id) => array(('k, 'a));

let fromArray: (array(('k, 'a)), ~id: id('k, 'id)) => t('k, 'a, 'id);

let keysToArray: t('k, 'a, 'b) => array('k);

let valuesToArray: t('b, 'a, 'c) => array('a);

let minKey: t('k, 'a, 'b) => option('k);

let minKeyUndefined: t('k, 'a, 'b) => Js.undefined('k);

let maxKey: t('k, 'a, 'b) => option('k);

let maxKeyUndefined: t('k, 'a, 'b) => Js.undefined('k);

let minimum: t('k, 'a, 'b) => option(('k, 'a));

let minUndefined: t('k, 'a, 'b) => Js.undefined(('k, 'a));

let maximum: t('k, 'a, 'b) => option(('k, 'a));

let maxUndefined: t('k, 'a, 'b) => Js.undefined(('k, 'a));

let get: (t('k, 'a, 'id), 'k) => option('a);

let getUndefined: (t('k, 'a, 'id), 'k) => Js.undefined('a);

let getWithDefault: (t('k, 'a, 'id), 'k, 'a) => 'a;

let getExn: (t('k, 'a, 'id), 'k) => 'a;

let checkInvariantInternal: t('a, 'b, 'c) => unit;

Raise when invariant is not held.

let remove: (t('k, 'a, 'id), 'k) => unit;

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

let removeMany: (t('k, 'a, 'id), array('k)) => unit;

let set: (t('k, 'a, 'id), 'k, 'a) => unit;

set(m, x, y) do the in-place modification

let updateU: (t('k, 'a, 'id), 'k, [@bs] (option('a) => option('a))) => unit;

let update: (t('k, 'a, 'id), 'k, option('a) => option('a)) => unit;

let mergeMany: (t('k, 'a, 'id), array(('k, 'a))) => unit;

let mapU: (t('k, 'a, 'id), [@bs] ('a => 'b)) => t('k, 'b, 'id);

let map: (t('k, 'a, 'id), 'a => 'b) => t('k, 'b, 'id);

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('k, 'a, 'id), [@bs] (('k, 'a) => 'b)) => t('k, 'b, 'id);

let mapWithKey: (t('k, 'a, 'id), ('k, 'a) => 'b) => t('k, 'b, 'id);