Module MutableMap.Int

type key = int

type key = int;

type 'a t

type t('a);

val make : unit -> 'a t

let make: unit => t('a);

val clear : 'a t -> unit

let clear: t('a) => unit;

val isEmpty : 'a t -> bool

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

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

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

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

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

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

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

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

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

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

let eq: t('a) => t('a) => ('a => 'a => bool) => bool;

eq m1 m2 cmp

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

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

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

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.

val reduceU : 'a t -> 'b -> ('b -> key -> 'a -> 'b) Js.Fn.arity3 -> 'b

let reduceU: t('a) => 'b => Js.Fn.arity3(('b => key => 'a => 'b)) => 'b;

val reduce : 'a t -> 'b -> ('b -> key -> 'a -> 'b) -> 'b

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.

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

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

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

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.

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

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

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

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.

val size : 'a t -> int

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

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

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

In increasing order

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

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

In increasing order

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

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

val keysToArray : 'a t -> key array

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

val valuesToArray : 'a t -> 'a array

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

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 : 'a t -> (key * 'a) option

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

val checkInvariantInternal : _ t -> unit

let checkInvariantInternal: t(_) => unit;

raise when invariant is not held

val remove : 'a t -> key -> unit

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

remove m x do the in-place modification

val removeMany : 'a t -> key array -> unit

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

val set : 'a t -> key -> 'a -> unit

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.

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

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

val update : 'a t -> key -> ('a option -> 'a option) -> unit

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

val mapU : 'a t -> ('a -> 'b) Js.Fn.arity1 -> 'b t

let mapU: t('a) => Js.Fn.arity1(('a => 'b)) => t('b);

val map : 'a t -> ('a -> 'b) -> 'b t

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.

val mapWithKeyU : 'a t -> (key -> 'a -> 'b) Js.Fn.arity2 -> 'b t

let mapWithKeyU: t('a) => Js.Fn.arity2((key => 'a => 'b)) => t('b);

val mapWithKey : 'a t -> (key -> 'a -> 'b) -> 'b t

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