Docs / API / Belt / Mutablemap

MutableMap

Belt.MutableMap

The top level provides generic mutable map operations.

It also has two specialized inner modules Belt.MutableMap.Int and Belt.MutableMap.String

t

RESCRIPT

type t<'k, 'v, 'id>

id

RESCRIPT

type id<'key, 'id> = Belt_Id.comparable<'key, 'id>

make

RESCRIPT

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

clear

RESCRIPT

let clear: t<'a, 'b, 'c> => unit

isEmpty

RESCRIPT

let isEmpty: t<'a, 'b, 'c> => bool

has

RESCRIPT

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

cmpU

Deprecated

Use cmp instead

RESCRIPT

let cmpU: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, ('a, 'a) => int) => int

cmp

RESCRIPT

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

Deprecated

Use eq instead

RESCRIPT

let eqU: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, ('a, 'a) => bool) => bool

eq

RESCRIPT

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

Deprecated

Use forEach instead

RESCRIPT

let forEachU: (t<'k, 'a, 'id>, ('k, 'a) => unit) => unit

forEach

RESCRIPT

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

Deprecated

Use reduce instead

RESCRIPT

let reduceU: (t<'k, 'a, 'id>, 'b, ('b, 'k, 'a) => 'b) => 'b

reduce

RESCRIPT

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

Deprecated

Use every instead

RESCRIPT

let everyU: (t<'k, 'a, 'id>, ('k, 'a) => bool) => bool

every

RESCRIPT

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

Deprecated

Use some instead

RESCRIPT

let someU: (t<'k, 'a, 'id>, ('k, 'a) => bool) => bool

some

RESCRIPT

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

RESCRIPT

let size: t<'k, 'a, 'id> => int

toList

RESCRIPT

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

In increasing order.

toArray

RESCRIPT

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

fromArray

RESCRIPT

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

keysToArray

RESCRIPT

let keysToArray: t<'k, 'a, 'b> => array<'k>

valuesToArray

RESCRIPT

let valuesToArray: t<'b, 'a, 'c> => array<'a>

minKey

RESCRIPT

let minKey: t<'k, 'a, 'b> => option<'k>

minKeyUndefined

RESCRIPT

let minKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>

maxKey

RESCRIPT

let maxKey: t<'k, 'a, 'b> => option<'k>

maxKeyUndefined

RESCRIPT

let maxKeyUndefined: t<'k, 'a, 'b> => Js.undefined<'k>

minimum

RESCRIPT

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

minUndefined

RESCRIPT

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

maximum

RESCRIPT

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

maxUndefined

RESCRIPT

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

get

RESCRIPT

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

getUndefined

RESCRIPT

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

getWithDefault

RESCRIPT

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

getExn

RESCRIPT

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

getOrThrow

RESCRIPT

let getOrThrow: (t<'k, 'a, 'id>, 'k) => 'a

checkInvariantInternal

RESCRIPT

let checkInvariantInternal: t<'a, 'b, 'c> => unit

Throw when invariant is not held.

remove

RESCRIPT

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

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

removeMany

RESCRIPT

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

set

RESCRIPT

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

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

updateU

Deprecated

Use update instead

RESCRIPT

let updateU: (t<'k, 'a, 'id>, 'k, option<'a> => option<'a>) => unit

update

RESCRIPT

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

mergeMany

RESCRIPT

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

mapU

Deprecated

Use map instead

RESCRIPT

let mapU: (t<'k, 'a, 'id>, 'a => 'b) => t<'k, 'b, 'id>

map

RESCRIPT

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

Deprecated

Use mapWithKey instead

RESCRIPT

let mapWithKeyU: (t<'k, 'a, 'id>, ('k, 'a) => 'b) => t<'k, 'b, 'id>

mapWithKey

RESCRIPT

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