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 key = int;

type 'value t

type t('value);

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

val empty : 'v t

let empty: t('v);

val isEmpty : 'v t -> bool

let isEmpty: t('v) => bool;

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

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

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

let cmpU: t('v) => t('v) => Js.Fn.arity2(('v => 'v => int)) => int;

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

let cmp: t('v) => t('v) => ('v => 'v => int) => int;

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

let eqU: t('v) => t('v) => Js.Fn.arity2(('v => 'v => bool)) => bool;

val eq : 'v t -> 'v t -> ('v -> 'v -> bool) -> bool

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.

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

let findFirstByU: 
  t('v) =>
  Js.Fn.arity2((key => 'v => bool)) =>
  option((key, 'v));

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

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.

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

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

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

let forEachU: t('v) => Js.Fn.arity2((key => 'v => unit)) => unit;

val forEach : 'v t -> (key -> 'v -> unit) -> unit

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.

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

let reduceU: t('v) => 'v2 => Js.Fn.arity3(('v2 => key => 'v => 'v2)) => 'v2;

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

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.

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

let everyU: t('v) => Js.Fn.arity2((key => 'v => bool)) => bool;

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

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

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

let someU: t('v) => Js.Fn.arity2((key => 'v => bool)) => bool;

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

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

val size : 'v t -> int

let size: t('v) => int;

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

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

In increasing order.

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

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

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

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

val keysToArray : 'v t -> key array

let keysToArray: t('v) => array(key);

val valuesToArray : 'v t -> 'v array

let valuesToArray: t('v) => array('v);

val minKey : _ t -> key option

let minKey: t(_) => option(key);

val minKeyUndefined : _ t -> key Js.undefined

let minKeyUndefined: t(_) => Js.undefined(key);

val maxKey : _ t -> key option

let maxKey: t(_) => option(key);

val maxKeyUndefined : _ t -> key Js.undefined

let maxKeyUndefined: t(_) => Js.undefined(key);

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

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

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

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

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

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

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

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

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

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

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

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

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

let getWithDefault: t('v) => key => 'v => 'v;

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

let getExn: t('v) => key => 'v;

val checkInvariantInternal : _ t -> unit

let checkInvariantInternal: t(_) => unit;

raise when invariant is not held

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

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.

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

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

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

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.

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

let updateU: t('v) => key => Js.Fn.arity1((option('v) => option('v))) => t('v);

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

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

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

let mergeU: 
  t('v) =>
  t('v2) =>
  Js.Fn.arity3((key => option('v) => option('v2) => option('c))) =>
  t('c);

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

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.

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

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

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

let keepU: t('v) => Js.Fn.arity2((key => 'v => bool)) => t('v);

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

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.

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

let partitionU: t('v) => Js.Fn.arity2((key => 'v => bool)) => (t('v), t('v));

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

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.

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

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.

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

let mapU: t('v) => Js.Fn.arity1(('v => 'v2)) => t('v2);

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

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.

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

let mapWithKeyU: t('v) => Js.Fn.arity2((key => 'v => 'v2)) => t('v2);

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

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