MutableMapString

key

RE
type key = string;

t

RE
type t('a);

make

RE
let make: unit => t('a);

clear

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

isEmpty

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

has

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

cmpU

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

cmp

RE
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

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

eq

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

eq(m1, m2, cmp)

forEachU

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

forEach

RE
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

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

reduce

RE
let reduce: (t('a), 'b, ('b, key, '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('a), [@bs] ((key, 'a) => bool)) => bool;

every

RE
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

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

some

RE
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

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

toList

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

In increasing order

toArray

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

fromArray

RE
let fromArray: array((key, 'a)) => t('a);

keysToArray

RE
let keysToArray: t('a) => array(key);

valuesToArray

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

minKey

RE
let minKey: t('a) => option(key);

minKeyUndefined

RE
let minKeyUndefined: t('a) => Js.undefined(key);

maxKey

RE
let maxKey: t('a) => option(key);

maxKeyUndefined

RE
let maxKeyUndefined: t('a) => Js.undefined(key);

minimum

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

minUndefined

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

maximum

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

maxUndefined

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

get

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

getUndefined

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

getWithDefault

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

getExn

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

checkInvariantInternal

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

Raise when invariant is not held.

remove

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

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

removeMany

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

set

RE
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

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

update

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

mapU

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

map

RE
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

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

mapWithKey

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