String
key
type key = string
t
type t<'value>
The type of maps from type key
to type 'value
.
empty
let empty: t<'v>
isEmpty
let isEmpty: t<'v> => bool
has
let has: (t<'v>, key) => bool
cmpU
let cmpU: (t<'v>, t<'v>, ('v, 'v) => int) => int
cmp
let cmp: (t<'v>, t<'v>, ('v, 'v) => int) => int
eqU
let eqU: (t<'v>, t<'v>, ('v, 'v) => bool) => bool
eq
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
let findFirstByU: (t<'v>, (key, 'v) => bool) => option<(key, 'v)>
findFirstBy
let findFirstBy: (t<'v>, (key, 'v) => bool) => option<(key, 'v)>
findFirstBy(m, p)
uses funcion f
to find the first key value pair
to match predicate p
.
RESCRIPTlet s0 = fromArray(~id=module(IntCmp), [(4, "4"), (1, "1"), (2, "2,"(3, ""))])
findFirstBy(s0, (k, v) => k == 4) == option((4, "4"))
forEachU
let forEachU: (t<'v>, (key, 'v) => unit) => unit
forEach
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
let reduceU: (t<'v>, 'v2, ('v2, key, 'v) => 'v2) => 'v2
reduce
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
let everyU: (t<'v>, (key, 'v) => bool) => bool
every
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
let someU: (t<'v>, (key, 'v) => bool) => bool
some
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
let size: t<'v> => int
toList
let toList: t<'v> => list<(key, 'v)>
In increasing order.
toArray
let toArray: t<'v> => array<(key, 'v)>
fromArray
let fromArray: array<(key, 'v)> => t<'v>
keysToArray
let keysToArray: t<'v> => array<key>
valuesToArray
let valuesToArray: t<'v> => array<'v>
minKey
let minKey: t<'a> => option<key>
minKeyUndefined
let minKeyUndefined: t<'a> => Js.undefined<key>
maxKey
let maxKey: t<'a> => option<key>
maxKeyUndefined
let maxKeyUndefined: t<'a> => Js.undefined<key>
minimum
let minimum: t<'v> => option<(key, 'v)>
minUndefined
let minUndefined: t<'v> => Js.undefined<(key, 'v)>
maximum
let maximum: t<'v> => option<(key, 'v)>
maxUndefined
let maxUndefined: t<'v> => Js.undefined<(key, 'v)>
get
let get: (t<'v>, key) => option<'v>
getUndefined
let getUndefined: (t<'v>, key) => Js.undefined<'v>
getWithDefault
let getWithDefault: (t<'v>, key, 'v) => 'v
getExn
let getExn: (t<'v>, key) => 'v
checkInvariantInternal
let checkInvariantInternal: t<'a> => unit
raise when invariant is not held
remove
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
let removeMany: (t<'v>, array<key>) => t<'v>
set
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
let updateU: (t<'v>, key, option<'v> => option<'v>) => t<'v>
update
let update: (t<'v>, key, option<'v> => option<'v>) => t<'v>
mergeU
let mergeU: (
t<'v>,
t<'v2>,
(key, option<'v>, option<'v2>) => option<'c>,
) => t<'c>
merge
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
let mergeMany: (t<'v>, array<(key, 'v)>) => t<'v>
keepU
let keepU: (t<'v>, (key, 'v) => bool) => t<'v>
keep
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
let partitionU: (t<'v>, (key, 'v) => bool) => (t<'v>, t<'v>)
partition
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
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
let mapU: (t<'v>, 'v => 'v2) => t<'v2>
map
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
let mapWithKeyU: (t<'v>, (key, 'v) => 'v2) => t<'v2>
mapWithKey
let mapWithKey: (t<'v>, (key, 'v) => 'v2) => t<'v2>