MutableMap

Same as Belt.Map, but mutable.

t

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

id

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

make

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

clear

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

isEmpty

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

has

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

cmpU

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

cmp

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

eqU

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

eq

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

forEachU

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

forEach

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

reduceU

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

reduce

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

everyU

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

every

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

someU

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

some

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

size

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

toList

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

In increasing order.

toArray

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

fromArray

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

keysToArray

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

valuesToArray

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

minKey

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

minKeyUndefined

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

maxKey

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

maxKeyUndefined

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

minimum

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

minUndefined

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

maximum

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

maxUndefined

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

get

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

getUndefined

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

getWithDefault

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

getExn

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

checkInvariantInternal

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

Raise when invariant is not held.

remove

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

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

removeMany

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

set

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

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

updateU

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

update

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

mergeMany

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

mapU

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

map

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

mapWithKeyU

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

mapWithKey

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