API / Belt / MutableMapInt

You are currently looking at the v6.0 - v8.2 docs (Reason v3.6 syntax edition). You can find the latest API docs here.

(These docs cover all versions between v3 to v8 and are equivalent to the old BuckleScript docs before the rebrand)

MutableMapInt

key

RE
type key = int;

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);