API / Belt / MutableMapString

You are currently looking at the < v8.2.0 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)

MutableMapString

key

type key = string;

t

type t('a);

make

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

clear

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

isEmpty

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

has

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

cmpU

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

cmp

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

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

eq

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

eq(m1, m2, cmp)

forEachU

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

forEach

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

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

reduce

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

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

every

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

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

some

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

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

toList

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

In increasing order

toArray

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

fromArray

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

keysToArray

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

valuesToArray

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

minKey

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

minKeyUndefined

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

maxKey

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

maxKeyUndefined

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

minimum

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

minUndefined

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

maximum

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

maxUndefined

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

get

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

getUndefined

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

getWithDefault

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

getExn

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

checkInvariantInternal

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

Raise when invariant is not held.

remove

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

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

removeMany

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

set

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

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

update

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

mapU

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

map

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

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

mapWithKey

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