Int

Examples

RESCRIPT
type t<'key, 'value, 'identity>
type id<'key, 'id> = Belt_Id.comparable<'key, 'id>

checkInvariantInternal

RESCRIPT

let checkInvariantInternal: t<'a> => unit

throw when invariant is not held

cmp

RESCRIPT

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

cmpU

Deprecated

Use cmp instead

RESCRIPT

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

empty

RESCRIPT

let empty: t<'v>

eq

RESCRIPT

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.

eqU

Deprecated

Use eq instead

RESCRIPT

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

every

RESCRIPT

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

everyU

Deprecated

Use every instead

RESCRIPT

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

findFirstBy

RESCRIPT

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.

Examples

RESCRIPT
let mapInt = Belt.Map.Int.fromArray([(1, "one"), (2, "two"), (3, "three")])

mapInt->Belt.Map.Int.findFirstBy((k, v) => k == 1 && v == "one") == Some(1, "one")

findFirstByU

Deprecated

Use findFirstBy instead

RESCRIPT

let findFirstByU: (t<'v>, (key, 'v) => bool) => option<(key, 'v)>

forEach

RESCRIPT

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.

forEachU

Deprecated

Use forEach instead

RESCRIPT

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

fromArray

RESCRIPT

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

get

RESCRIPT

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

getExn

RESCRIPT

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

getOrThrow

RESCRIPT

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

getUndefined

RESCRIPT

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

getWithDefault

RESCRIPT

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

has

RESCRIPT

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

isEmpty

RESCRIPT

let isEmpty: t<'v> => bool

keep

RESCRIPT

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.

keepU

Deprecated

Use keep instead

RESCRIPT

let keepU: (t<'v>, (key, 'v) => bool) => t<'v>

key

RESCRIPT

type key = int

keysToArray

RESCRIPT

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

map

RESCRIPT

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.

mapU

Deprecated

Use map instead

RESCRIPT

let mapU: (t<'v>, 'v => 'v2) => t<'v2>

mapWithKey

RESCRIPT

let mapWithKey: (t<'v>, (key, 'v) => 'v2) => t<'v2>

mapWithKeyU

Deprecated

Use mapWithKey instead

RESCRIPT

let mapWithKeyU: (t<'v>, (key, 'v) => 'v2) => t<'v2>

maximum

RESCRIPT

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

maxKey

RESCRIPT

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

maxKeyUndefined

RESCRIPT

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

maxUndefined

RESCRIPT

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

merge

RESCRIPT

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

RESCRIPT

let mergeMany: (t<'v>, array<(key, 'v)>) => t<'v>

mergeU

Deprecated

Use merge instead

RESCRIPT

let mergeU: (
  t<'v>,
  t<'v2>,
  (key, option<'v>, option<'v2>) => option<'c>,
) => t<'c>

minimum

RESCRIPT

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

minKey

RESCRIPT

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

minKeyUndefined

RESCRIPT

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

minUndefined

RESCRIPT

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

partition

RESCRIPT

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.

partitionU

Deprecated

Use partition instead

RESCRIPT

let partitionU: (t<'v>, (key, 'v) => bool) => (t<'v>, t<'v>)

reduce

RESCRIPT

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.

reduceU

Deprecated

Use reduce instead

RESCRIPT

let reduceU: (t<'v>, 'v2, ('v2, key, 'v) => 'v2) => 'v2

remove

RESCRIPT

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

RESCRIPT

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

set

RESCRIPT

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.

size

RESCRIPT

let size: t<'v> => int

some

RESCRIPT

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

someU

Deprecated

Use some instead

RESCRIPT

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

split

RESCRIPT

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.

t

RESCRIPT

type t<'value>

The type of maps from type key to type 'value.

toArray

RESCRIPT

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

toList

RESCRIPT

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

In increasing order.

update

RESCRIPT

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

updateU

Deprecated

Use update instead

RESCRIPT

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

valuesToArray

RESCRIPT

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