MapDict

t

RE
type t('key, 'value, 'id);

cmp

RE
type cmp('key, 'id) = Belt_Id.cmp('key, 'id);

empty

RE
let empty: t('k, 'v, 'id);

isEmpty

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

has

RE
let has: (t('k, 'a, 'id), 'k, ~cmp: cmp('k, 'id)) => bool;

cmpU

RE
let cmpU:
  (t('k, 'v, 'id), t('k, 'v, 'id), ~kcmp: cmp('k, 'id), ~vcmp: [@bs] (('v, 'v) => int)) => int;

cmp

RE
let cmp: (t('k, 'v, 'id), t('k, 'v, 'id), ~kcmp: cmp('k, 'id), ~vcmp: ('v, 'v) => int) => int;

eqU

RE
let eqU:
  (t('k, 'a, 'id), t('k, 'a, 'id), ~kcmp: cmp('k, 'id), ~veq: [@bs] (('a, 'a) => bool)) => bool;

eq

RE
let eq: (t('k, 'a, 'id), t('k, 'a, 'id), ~kcmp: cmp('k, 'id), ~veq: ('a, 'a) => bool) => bool;

eq(m1, m2, cmp) tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data. cmp is the equality predicate used to compare the data associated with the keys.

findFirstByU

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

findFirstBy

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

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

RE
module IntCmp =
  Belt.Id.MakeComparable({
    type t = int;
    let cmp = Pervasives.compare;
  });

let s0 = Belt.Map.Dict.fromArray([|(4, "4"), (1, "1"), (2, "2"), (3, "3")|], ~cmp=IntCmp.cmp);

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

forEachU

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

forEach

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

reduceU

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

reduce

RE
let reduce: (t('k, 'a, 'id), 'b, ('b, 'k, 'a) => 'b) => 'b;

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('k, 'a, 'id), [@bs] (('k, 'a) => bool)) => bool;

every

RE
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. Order unspecified

someU

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

some

RE
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. Order unspecified

size

RE
let size: t('k, 'a, 'id) => int;

toList

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

In increasing order.

toArray

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

fromArray

RE
let fromArray: (array(('k, 'a)), ~cmp: cmp('k, 'id)) => t('k, 'a, 'id);

keysToArray

RE
let keysToArray: t('k, 'a, 'id) => array('k);

valuesToArray

RE
let valuesToArray: t('k, 'a, 'id) => array('a);

minKey

RE
let minKey: t('k, 'a, 'b) => option('k);

minKeyUndefined

RE
let minKeyUndefined: t('k, 'a, 'b) => Js.undefined('k);

maxKey

RE
let maxKey: t('k, 'a, 'b) => option('k);

maxKeyUndefined

RE
let maxKeyUndefined: t('k, 'a, 'b) => Js.undefined('k);

minimum

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

minUndefined

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

maximum

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

maxUndefined

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

get

RE
let get: (t('k, 'a, 'id), 'k, ~cmp: cmp('k, 'id)) => option('a);

getUndefined

RE
let getUndefined: (t('k, 'a, 'id), 'k, ~cmp: cmp('k, 'id)) => Js.undefined('a);

getWithDefault

RE
let getWithDefault: (t('k, 'a, 'id), 'k, 'a, ~cmp: cmp('k, 'id)) => 'a;

getExn

RE
let getExn: (t('k, 'a, 'id), 'k, ~cmp: cmp('k, 'id)) => 'a;

checkInvariantInternal

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

remove

RE
let remove: (t('a, 'b, 'id), 'a, ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);

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('a, 'b, 'id), array('a), ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);

set

RE
let set: (t('a, 'b, 'id), 'a, 'b, ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);

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('a, 'b, 'id), 'a, [@bs] (option('b) => option('b)), ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);

update

RE
let update: (t('a, 'b, 'id), 'a, option('b) => option('b), ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);

mergeU

RE
let mergeU:
  (
    t('a, 'b, 'id),
    t('a, 'c, 'id),
    [@bs] (('a, option('b), option('c)) => option('d)),
    ~cmp: cmp('a, 'id)
  ) =>
  t('a, 'd, 'id);

merge

RE
let merge:
  (
    t('a, 'b, 'id),
    t('a, 'c, 'id),
    ('a, option('b), option('c)) => option('d),
    ~cmp: cmp('a, 'id)
  ) =>
  t('a, 'd, 'id);

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('a, 'b, 'id), array(('a, 'b)), ~cmp: cmp('a, 'id)) => t('a, 'b, 'id);

keepU

RE
let keepU: (t('k, 'a, 'id), [@bs] (('k, 'a) => bool)) => t('k, 'a, 'id);

keep

RE
let keep: (t('k, 'a, 'id), ('k, 'a) => bool) => t('k, 'a, 'id);

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

partitionU

RE
let partitionU: (t('k, 'a, 'id), [@bs] (('k, 'a) => bool)) => (t('k, 'a, 'id), t('k, 'a, 'id));

partition

RE
let partition: (t('k, 'a, 'id), ('k, 'a) => bool) => (t('k, 'a, 'id), t('k, 'a, 'id));

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:
  (t('a, 'b, 'id), 'a, ~cmp: cmp('a, 'id)) => ((t('a, 'b, 'id), t('a, 'b, 'id)), option('b));

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('k, 'a, 'id), [@bs] ('a => 'b)) => t('k, 'b, 'id);

map

RE
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

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

mapWithKey

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