HashMapString

key

RES
type key = string

Type of the Belt.HashMap.String key.

t

RES
type t<'b>

Type of the Belt.HashMap.String.

make

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

make(~hintSize=10) creates a new hash map by taking the hintSize.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)

Belt.HashMap.String.set(hMap, "key1", "a")

clear

let clear: t<'b> => unit

Clears a hash table.

RES
let hMap = Belt.HashMap.String.fromArray([("1", "1")])
Belt.HashMap.String.clear(hMap)
Belt.HashMap.String.isEmpty(hMap) == true

isEmpty

let isEmpty: t<'a> => bool

isEmpty(m) checks whether a hash map is empty.

RES
let hMap = Belt.HashMap.String.fromArray([("1", "1")])
Belt.HashMap.String.isEmpty(hMap) == false

set

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

set(tbl, k, v) if k does not exist, add the binding k,v, otherwise, update the old value with the new v.

RES
let hMap = Belt.HashMap.String.fromArray([("2", "2")])

Belt.HashMap.String.set(hMap, "1", "1")

Belt.HashMap.String.valuesToArray(hMap) == ["1", "2"]

copy

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

Creates copy of a hash map.

RES
let hMap1 = Belt.HashMap.String.fromArray([("1", "1"), ("2", "2")])
let hMap2 = Belt.HashMap.String.copy(hMap1)

Belt.HashMap.String.set(hMap2, "2", "3")

Belt.HashMap.String.get(hMap1, "2") != Belt.HashMap.String.get(hMap2, "2")

get

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

Returns value bound under specific key. If values not exist returns None.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "value1")

Belt.HashMap.String.get(hMap, "1") == Some("value1")
Belt.HashMap.String.get(hMap, "2") == None

has

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

Checks if x is bound in tbl.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "value1")

Belt.HashMap.String.has(hMap, "1") == true
Belt.HashMap.String.has(hMap, "2") == false

remove

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

If bound exists, removes it from the hash map.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "value1")
Belt.HashMap.String.remove(hMap, "1")
Belt.HashMap.String.has(hMap, "1") == false

forEachU

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

Same as forEach but takes uncurried functon.

forEach

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

forEach(tbl, f) applies f to all bindings in table tbl. f receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to f.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "value1")
Belt.HashMap.String.forEach(hMap, (key, value) => Js.log2(key, value))
// prints ("1", "value1")

reduceU

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

Same as reduce but takes uncurried functon.

reduce

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

reduce(tbl, init, f) computes (f(kN, dN) ... (f(k1, d1, init))...), where k1 ... kN are the keys of all bindings in tbl, and d1 ... dN are the associated values. Each binding is presented exactly once to f.

The order in which the bindings are passed to f is unspecified. However, if the table contains several bindings for the same key, they are passed to f in reverse order of introduction, that is, the most recent binding is passed first.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "value1")
Belt.HashMap.String.set(hMap, "2", "value2")

Belt.HashMap.String.reduce(hMap, "", (acc, key, value) =>
  acc ++ (", " ++ value)
) == "value1, value2"

keepMapInPlaceU

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

Same as keepMapInPlace but takes uncurried functon.

keepMapInPlace

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

Filters out values for which function f returned None.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "value1")
Belt.HashMap.String.set(hMap, "2", "value2")

Belt.HashMap.String.keepMapInPlace(hMap, (key, value) => key == "1" ? None : Some(value))

size

let size: t<'a> => int

size(tbl) returns the number of bindings in tbl. It takes constant time.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "value1")
Belt.HashMap.String.set(hMap, "2", "value2")

Belt.HashMap.String.size(hMap) == 2

toArray

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

Returns array of key value pairs.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "value1")
Belt.HashMap.String.set(hMap, "2", "value2")

Belt.HashMap.String.toArray(hMap) == [("1", "value1"), ("2", "value2")]

keysToArray

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

Returns array of keys.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "value1")
Belt.HashMap.String.set(hMap, "2", "value2")

Belt.HashMap.String.keysToArray(hMap) == ["1", "2"]

valuesToArray

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

Returns array of values.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "value1")
Belt.HashMap.String.set(hMap, "2", "value2")

Belt.HashMap.String.valuesToArray(hMap) == ["value1", "value2"]

fromArray

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

Creates new hash map from array of pairs.

Returns array of values.

RES
let hMap = Belt.HashMap.String.fromArray([("1", "value1"), ("2", "value2")])
Belt.HashMap.String.toArray(hMap) == [("1", "value1"), ("2", "value2")]

mergeMany

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

Merges many key value pairs into hash map.

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.mergeMany(hMap, [("1", "value1"), ("2", "value2")])

getBucketHistogram

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

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "1")

Belt.HashMap.String.getBucketHistogram(hMap)

logStats

let logStats: t<'a> => unit

RES
let hMap = Belt.HashMap.String.make(~hintSize=10)
Belt.HashMap.String.set(hMap, "1", "1")

Belt.HashMap.String.logStats(hMap)