API / Belt / Hashmap / String

String

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

key

RESCRIPT
type key = string

t

RESCRIPT
type t<'b>

make

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

clear

RESCRIPT
let clear: t<'b> => unit

isEmpty

RESCRIPT
let isEmpty: t<'a> => bool

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

copy

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

get

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

has

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

remove

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

forEachU

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

forEach

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

reduceU

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

reduce

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

keepMapInPlaceU

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

keepMapInPlace

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

size

RESCRIPT
let size: t<'a> => int

toArray

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

keysToArray

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

valuesToArray

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

fromArray

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

mergeMany

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

getBucketHistogram

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

logStats

RESCRIPT
let logStats: t<'a> => unit