API / Belt / MapDict

MapDict

This module separates identity from data, it is a bit more verbose but slightly more efficient due to the fact that there is no need to pack identity and data back after each operation

Advanced usage only

t

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

cmp

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

empty

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

isEmpty

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

has

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

cmpU

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

cmp

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

eqU

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

eq

RES
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

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

findFirstBy

RES
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

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

forEach

RES
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

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

reduce

RES
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

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

every

RES
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

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

some

RES
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

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

toList

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

In increasing order.

toArray

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

fromArray

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

keysToArray

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

valuesToArray

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

minKey

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

minKeyUndefined

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

maxKey

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

maxKeyUndefined

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

minimum

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

minUndefined

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

maximum

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

maxUndefined

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

get

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

getUndefined

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

getWithDefault

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

getExn

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

checkInvariantInternal

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

remove

RES
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

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

set

RES
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

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

update

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

mergeU

RES
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

RES
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

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

keepU

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

keep

RES
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

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

partition

RES
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

RES
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

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

map

RES
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

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

mapWithKey

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