Module HashMap.Int

Specalized when key type is int, more efficient than the generic type

type key = int

type key = int;

type 'b t

type t('b);

val make : hintSize:int -> 'b t

let make: hintSize:int => t('b);

val clear : 'b t -> unit

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

val isEmpty : _ t -> bool

let isEmpty: t(_) => bool;

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

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

setDone tbl k v if k does not exist, add the binding k,v, otherwise, update the old value with the new v

val copy : 'a t -> 'a t

let copy: t('a) => t('a);

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

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

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

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

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

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

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

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

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

let forEach: t('b) => (key => 'b => unit) => unit;

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

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

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

let reduce: t('b) => 'c => ('c => key => 'b => 'c) => 'c;

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

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

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

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

val size : _ t -> int

let size: t(_) => int;

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

let toArray: t('a) => array((key, '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 fromArray : (key * 'a) array -> 'a t

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

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

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

val getBucketHistogram : _ t -> int array

let getBucketHistogram: t(_) => array(int);

val logStats : _ t -> unit

let logStats: t(_) => unit;