Module Map.Int

Specalized when key type is int, more efficient than the generic type, its compare behavior is fixed using the built-in comparison

type key = int

type 'value t

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

val empty : 'v t

val isEmpty : 'v t -> bool

val has : 'v t -> key -> bool

val cmpU : 'v t -> 'v t -> ('v -> 'v -> int) Js.Fn.arity2 -> int

val cmp : 'v t -> 'v t -> ('v -> 'v -> int) -> int

val eqU : 'v t -> 'v t -> ('v -> 'v -> bool) Js.Fn.arity2 -> bool

val eq : 'v t -> 'v t -> ('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.

val findFirstByU : 
  'v t ->
  (key -> 'v -> bool) Js.Fn.arity2 ->
  (key * 'v) option

val findFirstBy : 'v t -> (key -> 'v -> bool) -> (key * 'v) option

findFirstBy m p uses funcion f to find the first key value pair to match predicate p.

  let s0 = fromArray ~id:(module IntCmp) [|4,"4";1,"1";2,"2,"3""|];;
  findFirstBy s0 (fun k v -> k = 4 ) = option (4, "4");;

val forEachU : 'v t -> (key -> 'v -> unit) Js.Fn.arity2 -> unit

val forEach : 'v t -> (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.

val reduceU : 'v t -> 'v2 -> ('v2 -> key -> 'v -> 'v2) Js.Fn.arity3 -> 'v2

val reduce : 'v t -> '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.

val everyU : 'v t -> (key -> 'v -> bool) Js.Fn.arity2 -> bool

val every : 'v t -> (key -> 'v -> bool) -> bool

every m p checks if all the bindings of the map satisfy the predicate p. Order unspecified

val someU : 'v t -> (key -> 'v -> bool) Js.Fn.arity2 -> bool

val some : 'v t -> (key -> 'v -> bool) -> bool

some m p checks if at least one binding of the map satisfy the predicate p. Order unspecified

val size : 'v t -> int

val toList : 'v t -> (key * 'v) list

In increasing order.

val toArray : 'v t -> (key * 'v) array

val fromArray : (key * 'v) array -> 'v t

val keysToArray : 'v t -> key array

val valuesToArray : 'v t -> 'v array

val minKey : _ t -> key option

val minKeyUndefined : _ t -> key Js.undefined

val maxKey : _ t -> key option

val maxKeyUndefined : _ t -> key Js.undefined

val minimum : 'v t -> (key * 'v) option

val minUndefined : 'v t -> (key * 'v) Js.undefined

val maximum : 'v t -> (key * 'v) option

val maxUndefined : 'v t -> (key * 'v) Js.undefined

val get : 'v t -> key -> 'v option

val getUndefined : 'v t -> key -> 'v Js.undefined

val getWithDefault : 'v t -> key -> 'v -> 'v

val getExn : 'v t -> key -> 'v

val checkInvariantInternal : _ t -> unit

raise when invariant is not held

val remove : 'v t -> key -> 'v t

remove m x returns a map containing the same bindings as m, except for x which is unbound in the returned map.

val removeMany : 'v t -> key array -> 'v t

val set : 'v t -> key -> 'v -> 'v t

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.

val updateU : 'v t -> key -> ('v option -> 'v option) Js.Fn.arity1 -> 'v t

val update : 'v t -> key -> ('v option -> 'v option) -> 'v t

val mergeU : 
  'v t ->
  'v2 t ->
  (key -> 'v option -> 'v2 option -> 'c option) Js.Fn.arity3 ->
  'c t

val merge : 
  'v t ->
  'v2 t ->
  (key -> 'v option -> 'v2 option -> 'c option) ->
  'c t

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.

val mergeMany : 'v t -> (key * 'v) array -> 'v t

val keepU : 'v t -> (key -> 'v -> bool) Js.Fn.arity2 -> 'v t

val keep : 'v t -> (key -> 'v -> bool) -> 'v t

keep m p returns the map with all the bindings in m that satisfy predicate p.

val partitionU : 'v t -> (key -> 'v -> bool) Js.Fn.arity2 -> 'v t * 'v t

val partition : 'v t -> (key -> 'v -> bool) -> 'v t * 'v t

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.

val split : key -> 'v t -> 'v t * 'v option * 'v t

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.

val mapU : 'v t -> ('v -> 'v2) Js.Fn.arity1 -> 'v2 t

val map : 'v t -> ('v -> 'v2) -> 'v2 t

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.

val mapWithKeyU : 'v t -> (key -> 'v -> 'v2) Js.Fn.arity2 -> 'v2 t

val mapWithKey : 'v t -> (key -> 'v -> 'v2) -> 'v2 t