MapString

key

RE
type key = string;

t

RE
type t('value);

The type of maps from type key to type 'value.

empty

RE
let empty: t('v);

isEmpty

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

has

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

cmpU

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

cmp

RE
let cmp: (t('v), t('v), ('v, 'v) => int) => int;

eqU

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

eq

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

eq(m1, m2) tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data.

findFirstByU

RE
let findFirstByU: (t('v), [@bs] ((key, 'v) => bool)) => option((key, 'v));

findFirstBy

RE
let findFirstBy: (t('v), (key, 'v) => bool) => option((key, 'v));

findFirstBy(m, p) uses function f to find the first key value pair to match predicate p.

RE
let s0 = Belt.Map.String.fromArray([|("4", 4), ("1", 1), ("2", 2), ("3", 3)|]);

Belt.Map.String.findFirstBy(s0, (k, _) => k == "4") == Some(("4", 4));

forEachU

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

forEach

RE
let forEach: (t('v), (key, 'v) => 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 bindings are passed to f in increasing order with respect to the ordering over the type of the keys.

reduceU

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

reduce

RE
let reduce: (t('v), 'v2, ('v2, key, 'v) => 'v2) => 'v2;

reduce(m, a, f) computes f(kN, dN ... f(k1, d1, a)...), where k1 ... kN) are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.

everyU

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

every

RE
let every: (t('v), (key, 'v) => bool) => bool;

every(m, p) checks if all the bindings of the map satisfy the predicate p. Order unspecified

someU

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

some

RE
let some: (t('v), (key, 'v) => bool) => bool;

some(m, p) checks if at least one binding of the map satisfy the predicate p. Order unspecified

size

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

toList

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

In increasing order.

toArray

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

fromArray

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

keysToArray

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

valuesToArray

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

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('v) => option((key, 'v));

minUndefined

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

maximum

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

maxUndefined

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

get

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

getUndefined

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

getWithDefault

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

getExn

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

checkInvariantInternal

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

raise when invariant is not held

remove

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

remove(m, x) returns a map containing the same bindings as m, except for x which is unbound in the returned map.

removeMany

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

set

RE
let set: (t('v), key, 'v) => t('v);

set(m, x, y) returns a map containing the same bindings as m, plus a binding of x to y. If x was already bound in m, its previous binding disappears.

updateU

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

update

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

mergeU

RE
let mergeU: (t('v), t('v2), [@bs] ((key, option('v), option('v2)) => option('c))) => t('c);

merge

RE
let merge: (t('v), t('v2), (key, option('v), option('v2)) => option('c)) => t('c);

merge(m1, m2, f) computes a map whose keys is a subset of keys of m1 and of m2. The presence of each such binding, and the corresponding value, is determined with the function f.

mergeMany

RE
let mergeMany: (t('v), array((key, 'v))) => t('v);

keepU

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

keep

RE
let keep: (t('v), (key, 'v) => bool) => t('v);

keep(m, p) returns the map with all the bindings in m that satisfy predicate p.

partitionU

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

partition

RE
let partition: (t('v), (key, 'v) => bool) => (t('v), t('v));

partition(m, p) returns a pair of maps (m1, m2), where m1 contains all the bindings of s that satisfy the predicate p, and m2 is the map with all the bindings of s that do not satisfy p.

split

RE
let split: (key, t('v)) => (t('v), option('v), t('v));

split(x, m) returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some(v) if m binds v to x.

mapU

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

map

RE
let map: (t('v), 'v => 'v2) => t('v2);

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('v), [@bs] ((key, 'v) => 'v2)) => t('v2);

mapWithKey

RE
let mapWithKey: (t('v), (key, 'v) => 'v2) => t('v2);