Int

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

clear

RESCRIPT

let clear: t<'b> => unit

copy

RESCRIPT

let copy: t<'a> => t<'a>

forEach

RESCRIPT

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

forEachU

Deprecated

Use forEach instead

RESCRIPT

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

fromArray

RESCRIPT

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

get

RESCRIPT

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

getBucketHistogram

RESCRIPT

let getBucketHistogram: t<'a> => array<int>

has

RESCRIPT

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

isEmpty

RESCRIPT

let isEmpty: t<'a> => bool

keepMapInPlace

RESCRIPT

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

keepMapInPlaceU

Deprecated

Use keepMapInPlace instead

RESCRIPT

let keepMapInPlaceU: (t<'a>, (key, 'a) => option<'a>) => unit

key

RESCRIPT

type key = int

keysToArray

RESCRIPT

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

logStats

RESCRIPT

let logStats: t<'a> => unit

make

RESCRIPT

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

mergeMany

RESCRIPT

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

reduce

RESCRIPT

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

reduceU

Deprecated

Use reduce instead

RESCRIPT

let reduceU: (t<'b>, 'c, ('c, key, 'b) => 'c) => 'c

remove

RESCRIPT

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

set

RESCRIPT

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

size

RESCRIPT

let size: t<'a> => int

t

RESCRIPT

type t<'b>

toArray

RESCRIPT

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

valuesToArray

RESCRIPT

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