Dict
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
type t<'key, 'value, 'id>
cmp
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
.
Examples
RESCRIPTmodule 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>