String

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

clear

RES

let clear: t<'b> => unit

copy

RES

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

forEach

RES

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

forEachU

Deprecated

Use forEach instead

RES

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

fromArray

RES

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

get

RES

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

getBucketHistogram

RES

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

has

RES

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

isEmpty

RES

let isEmpty: t<'a> => bool

keepMapInPlace

RES

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

keepMapInPlaceU

Deprecated

Use keepMapInPlace instead

RES

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

key

RES

type key = string

keysToArray

RES

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

logStats

RES

let logStats: t<'a> => unit

make

RES

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

mergeMany

RES

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

reduce

RES

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

reduceU

Deprecated

Use reduce instead

RES

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

remove

RES

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

set

RES

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

RES

let size: t<'a> => int

t

RES

type t<'b>

toArray

RES

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

valuesToArray

RES

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