MutableMap.Int
let make: unit => t('a);
let clear: t('a) => unit;
let isEmpty: t('a) => bool;
let cmpU: t('a) => t('a) => Js.Fn.arity2(('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('a) => t('a) => Js.Fn.arity2(('a => 'a => bool)) => bool;
let forEachU: t('a) => Js.Fn.arity2((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.
let reduceU: t('a) => 'b => Js.Fn.arity3(('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.
let everyU: t('a) => Js.Fn.arity2((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.
let someU: t('a) => Js.Fn.arity2((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.
let size: t('a) => int;
let valuesToArray: t('a) => array('a);
let minKeyUndefined: t(_) => Js.undefined(key);
let maxKeyUndefined: t(_) => Js.undefined(key);
let minUndefined: t('a) => Js.undefined((key, 'a));
let maxUndefined: t('a) => Js.undefined((key, 'a));
let getUndefined: t('a) => key => Js.undefined('a);
let checkInvariantInternal: t(_) => unit;
raise when invariant is not held
set m x y
do the in-place modification, return m
for chaining. If x
was already bound in m
, its previous binding disappears.
let updateU: t('a) => key => Js.Fn.arity1((option('a) => option('a))) => unit;
let mapU: t('a) => Js.Fn.arity1(('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.
let mapWithKeyU: t('a) => Js.Fn.arity2((key => 'a => 'b)) => t('b);