MutableMapInt

key

RES
type key = int

t

RES
type t<'a>

make

RES
let make: unit => t<'a>

clear

RES
let clear: t<'a> => unit

isEmpty

RES
let isEmpty: t<'a> => bool

has

RES
let has: (t<'a>, key) => bool

cmpU

RES
let cmpU: (t<'a>, t<'a>, (. 'a, 'a) => int) => int

cmp

RES
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

RES
let eqU: (t<'a>, t<'a>, (. 'a, 'a) => bool) => bool

eq

RES
let eq: (t<'a>, t<'a>, ('a, 'a) => bool) => bool

eq(m1, m2, cmp)

forEachU

RES
let forEachU: (t<'a>, (. key, 'a) => unit) => unit

forEach

RES
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

RES
let reduceU: (t<'a>, 'b, (. 'b, key, 'a) => 'b) => 'b

reduce

RES
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

RES
let everyU: (t<'a>, (. key, 'a) => bool) => bool

every

RES
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

RES
let someU: (t<'a>, (. key, 'a) => bool) => bool

some

RES
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

RES
let size: t<'a> => int

toList

RES
let toList: t<'a> => list<(key, 'a)>

In increasing order

toArray

RES
let toArray: t<'a> => array<(key, 'a)>

fromArray

RES
let fromArray: array<(key, 'a)> => t<'a>

keysToArray

RES
let keysToArray: t<'a> => array<key>

valuesToArray

RES
let valuesToArray: t<'a> => array<'a>

minKey

RES
let minKey: t<'a> => option<key>

minKeyUndefined

RES
let minKeyUndefined: t<'a> => Js.undefined<key>

maxKey

RES
let maxKey: t<'a> => option<key>

maxKeyUndefined

RES
let maxKeyUndefined: t<'a> => Js.undefined<key>

minimum

RES
let minimum: t<'a> => option<(key, 'a)>

minUndefined

RES
let minUndefined: t<'a> => Js.undefined<(key, 'a)>

maximum

RES
let maximum: t<'a> => option<(key, 'a)>

maxUndefined

RES
let maxUndefined: t<'a> => Js.undefined<(key, 'a)>

get

RES
let get: (t<'a>, key) => option<'a>

getUndefined

RES
let getUndefined: (t<'a>, key) => Js.undefined<'a>

getWithDefault

RES
let getWithDefault: (t<'a>, key, 'a) => 'a

getExn

RES
let getExn: (t<'a>, key) => 'a

checkInvariantInternal

RES
let checkInvariantInternal: t<'a> => unit

Raise when invariant is not held.

remove

RES
let remove: (t<'a>, key) => unit

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

removeMany

RES
let removeMany: (t<'a>, array<key>) => unit

set

RES
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

RES
let updateU: (t<'a>, key, (. option<'a>) => option<'a>) => unit

update

RES
let update: (t<'a>, key, option<'a> => option<'a>) => unit

mapU

RES
let mapU: (t<'a>, (. 'a) => 'b) => t<'b>

map

RES
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

RES
let mapWithKeyU: (t<'a>, (. key, 'a) => 'b) => t<'b>

mapWithKey

RES
let mapWithKey: (t<'a>, (key, 'a) => 'b) => t<'b>