API / Belt / HashMap

HashMap

The top level provides generic mutable hash map operations.

t

RES
type t<'key, 'value, 'id>

The type of hash tables from type 'key to type 'value.

id

RES
type id<'a, 'id> = Belt.Id.hashable<'a, 'id>

The identity needed for making an empty hash map.

make

RES
let make: (~hintSize: int, ~id: id<'key, 'id>) => t<'key, 'value, 'id>

make(~hintSize=10, ~id) creates a new map by taking in the comparator and hintSize.

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))

Belt.HashMap.set(hMap, 0, "a")

clear

RES
let clear: t<'key, 'value, 'id> => unit

Clears a hash table.

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let hMap = Belt.HashMap.fromArray([(1, "1")], ~id=module(IntHash))
Belt.HashMap.clear(hMap)
Belt.HashMap.isEmpty(hMap) == true

isEmpty

RES
let isEmpty: t<'a, 'b, 'c> => bool

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

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

Belt.HashMap.isEmpty(Belt.HashMap.fromArray([(1, "1")], ~id=module(IntHash))) == false

set

RES
let set: (t<'key, 'value, 'id>, 'key, 'value) => unit

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

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntHash))

Belt.HashMap.set(s0, 2, "3")

Belt.HashMap.valuesToArray(s0) == ["1", "3", "3"]

copy

RES
let copy: t<'key, 'value, 'id> => t<'key, 'value, 'id>

Creates copy of a hash map.

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.fromArray([(2, "2"), (1, "1"), (3, "3")], ~id=module(IntHash))
let s1 = Belt.HashMap.copy(s0)

Belt.HashMap.set(s0, 2, "3")

Belt.HashMap.get(s0, 2) != Belt.HashMap.get(s1, 2)

get

RES
let get: (t<'key, 'value, 'id>, 'key) => option<'value>

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

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(s0, 1, "value1")

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

has

RES
let has: (t<'key, 'value, 'id>, 'key) => bool

Checks if x is bound in tbl.

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(s0, 1, "value1")

Belt.HashMap.has(s0, 1) == true
Belt.HashMap.has(s0, 2) == false

remove

RES
let remove: (t<'key, 'value, 'id>, 'key) => unit

If bound exists, removes it from the hash map.

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(s0, 1, "value1")
Belt.HashMap.remove(s0, 1)
Belt.HashMap.has(s0, 1) == false

forEachU

RES
let forEachU: (t<'key, 'value, 'id>, (. 'key, 'value) => unit) => unit

Same as forEach but takes uncurried functon.

forEach

RES
let forEach: (t<'key, 'value, 'id>, ('key, 'value) => 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
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(s0, 1, "value1")
Belt.HashMap.forEach(s0, (key, value) => Js.log2(key, value))
// prints (1, "value1")

reduceU

RES
let reduceU: (t<'key, 'value, 'id>, 'c, (. 'c, 'key, 'value) => 'c) => 'c

Same as reduce but takes uncurried functon.

reduce

RES
let reduce: (t<'key, 'value, 'id>, 'c, ('c, 'key, 'value) => '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
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(s0, 1, "value1")
Belt.HashMap.set(s0, 2, "value2")

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

keepMapInPlaceU

RES
let keepMapInPlaceU: (t<'key, 'value, 'id>, (. 'key, 'value) => option<'value>) => unit

Same as keepMapInPlace but takes uncurried functon.

keepMapInPlace

RES
let keepMapInPlace: (t<'key, 'value, 'id>, ('key, 'value) => option<'value>) => unit

Filters out values for which function f returned None.

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(s0, 1, "value1")
Belt.HashMap.set(s0, 2, "value2")

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

size

RES
let size: t<'a, 'b, 'c> => int

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

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(s0, 1, "value1")
Belt.HashMap.set(s0, 2, "value2")

Belt.HashMap.size(s0) == 2

toArray

RES
let toArray: t<'key, 'value, 'id> => array<('key, 'value)>

Returns array of key value pairs.

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(s0, 1, "value1")
Belt.HashMap.set(s0, 2, "value2")

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

keysToArray

RES
let keysToArray: t<'key, 'a, 'b> => array<'key>

Returns array of keys.

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(s0, 1, "value1")
Belt.HashMap.set(s0, 2, "value2")

Belt.HashMap.keysToArray(s0) == [1, 2]

valuesToArray

RES
let valuesToArray: t<'a, 'value, 'b> => array<'value>

Returns array of values.

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(s0, 1, "value1")
Belt.HashMap.set(s0, 2, "value2")

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

fromArray

RES
let fromArray: (array<('key, 'value)>, ~id: id<'key, 'id>) => t<'key, 'value, 'id>

Creates new hash map from array of pairs.

Returns array of values.

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let s0 = Belt.HashMap.fromArray([(1, "value1"), (2, "value2")], ~id=module(IntHash))
Belt.HashMap.toArray(s0) == [(1, "value1"), (2, "value2")]

mergeMany

RES
let mergeMany: (t<'key, 'value, 'id>, array<('key, 'value)>) => unit

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})

let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.mergeMany(hMap, [(1, "1"), (2, "2")])

getBucketHistogram

RES
let getBucketHistogram: t<'a, 'b, 'c> => array<int>

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})
let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(hMap, 1, "1")

Belt.HashMap.getBucketHistogram(hMap)

logStats

RES
let logStats: t<'a, 'b, 'c> => unit

RES
module IntHash = Belt.Id.MakeHashableU({
  type t = int
  let hash = a => a
  let eq = (a, b) => a == b
})
let hMap = Belt.HashMap.make(~hintSize=10, ~id=module(IntHash))
Belt.HashMap.set(hMap, 1, "1")

Belt.HashMap.logStats(hMap)