MapDict

t

RES
type t<'key, 'value, 'id>

cmp

RES
type cmp<'key, 'id> = Belt_Id.cmp<'key, 'id>

empty

let empty: t<'k, 'v, 'id>

isEmpty

let isEmpty: t<'k, 'v, 'id> => bool

has

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

cmpU

let cmpU: (t<'k, 'v, 'id>, t<'k, 'v, 'id>, ~kcmp: cmp<'k, 'id>, ~vcmp: (. 'v, 'v) => int) => int

cmp

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

eqU

let eqU: (t<'k, 'a, 'id>, t<'k, 'a, 'id>, ~kcmp: cmp<'k, 'id>, ~veq: (. 'a, 'a) => bool) => bool

eq

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

let findFirstByU: (t<'k, 'v, 'id>, (. 'k, 'v) => bool) => option<('k, 'v)>

findFirstBy

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.

RES
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

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

forEach

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

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

reduce

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

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

every

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

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

some

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

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

toList

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

In increasing order.

toArray

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

fromArray

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

keysToArray

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

valuesToArray

let valuesToArray: t<'k, 'a, 'id> => array<'a>

minKey

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

minKeyUndefined

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

maxKey

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

maxKeyUndefined

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

minimum

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

minUndefined

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

maximum

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

maxUndefined

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

get

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

getUndefined

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

getWithDefault

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

getExn

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

checkInvariantInternal

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

remove

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

let removeMany: (t<'a, 'b, 'id>, array<'a>, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>

set

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

let updateU: (
  t<'a, 'b, 'id>,
  'a,
  (. option<'b>) => option<'b>,
  ~cmp: cmp<'a, 'id>,
) => t<'a, 'b, 'id>

update

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

mergeU

let mergeU: (
  t<'a, 'b, 'id>,
  t<'a, 'c, 'id>,
  (. 'a, option<'b>, option<'c>) => option<'d>,
  ~cmp: cmp<'a, 'id>,
) => t<'a, 'd, 'id>

merge

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

let mergeMany: (t<'a, 'b, 'id>, array<('a, 'b)>, ~cmp: cmp<'a, 'id>) => t<'a, 'b, 'id>

keepU

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

keep

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

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

partition

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

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

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

map

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

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

mapWithKey

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