String

checkInvariantInternal

RES

let checkInvariantInternal: t<'a> => unit

throw when invariant is not held

clear

RES

let clear: t<'a> => unit

cmp

RES

let cmp: (t<'a>, t<'a>, ('a, 'a) => int) => int

cmp(m1, m2, cmp). First compare by size, if size is the same, compare by key, value pair

cmpU

Deprecated

Use cmp instead

RES

let cmpU: (t<'a>, t<'a>, ('a, 'a) => int) => int

eq

RES

let eq: (t<'a>, t<'a>, ('a, 'a) => bool) => bool

eq(m1, m2, cmp)

eqU

Deprecated

Use eq instead

RES

let eqU: (t<'a>, t<'a>, ('a, 'a) => bool) => bool

every

RES

let every: (t<'a>, (key, 'a) => bool) => bool

every(m, p) checks if all the bindings of the map satisfy the predicate p. The application order of p is unspecified.

everyU

Deprecated

Use every instead

RES

let everyU: (t<'a>, (key, 'a) => bool) => bool

forEach

RES

let forEach: (t<'a>, (key, '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 application order of f is in increasing order.

forEachU

Deprecated

Use forEach instead

RES

let forEachU: (t<'a>, (key, 'a) => unit) => unit

fromArray

RES

let fromArray: array<(key, 'a)> => t<'a>

get

RES

let get: (t<'a>, key) => option<'a>

getExn

RES

let getExn: (t<'a>, key) => 'a

getOrThrow

RES

let getOrThrow: (t<'a>, key) => 'a

getUndefined

RES

let getUndefined: (t<'a>, key) => Js.undefined<'a>

getWithDefault

RES

let getWithDefault: (t<'a>, key, 'a) => 'a

has

RES

let has: (t<'a>, key) => bool

isEmpty

RES

let isEmpty: t<'a> => bool

key

RES

type key = string

keysToArray

RES

let keysToArray: t<'a> => array<key>

make

RES

let make: unit => t<'a>

map

RES

let map: (t<'a>, 'a => 'b) => t<'b>

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.

mapU

Deprecated

Use map instead

RES

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

mapWithKey

RES

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

mapWithKeyU

Deprecated

Use mapWithKey instead

RES

let mapWithKeyU: (t<'a>, (key, 'a) => 'b) => t<'b>

maximum

RES

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

maxKey

RES

let maxKey: t<'a> => option<key>

maxKeyUndefined

RES

let maxKeyUndefined: t<'a> => Js.undefined<key>

maxUndefined

RES

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

minimum

RES

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

minKey

RES

let minKey: t<'a> => option<key>

minKeyUndefined

RES

let minKeyUndefined: t<'a> => Js.undefined<key>

minUndefined

RES

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

reduce

RES

let reduce: (t<'a>, 'b, ('b, key, '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.

reduceU

Deprecated

Use reduce instead

RES

let reduceU: (t<'a>, 'b, ('b, key, 'a) => 'b) => 'b

remove

RES

let remove: (t<'a>, key) => unit

remove(m, x) do the in-place modification

removeMany

RES

let removeMany: (t<'a>, array<key>) => unit

set

RES

let set: (t<'a>, key, 'a) => unit

set(m, x, y) do the in-place modification, return m for chaining. If x was already bound in m, its previous binding disappears.

size

RES

let size: t<'a> => int

some

RES

let some: (t<'a>, (key, 'a) => bool) => bool

some(m, p) checks if at least one binding of the map satisfy the predicate p. The application order of p is unspecified.

someU

Deprecated

Use some instead

RES

let someU: (t<'a>, (key, 'a) => bool) => bool

t

RES

type t<'a>

toArray

RES

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

In increasing order

toList

RES

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

In increasing order

update

RES

let update: (t<'a>, key, option<'a> => option<'a>) => unit

updateU

Deprecated

Use update instead

RES

let updateU: (t<'a>, key, option<'a> => option<'a>) => unit

valuesToArray

RES

let valuesToArray: t<'a> => array<'a>