HashMap

A mutable Hash map which allows customized hash behavior.

All data are parameterized by not its only type but also a unique identity in the time of initialization, so that two HashMaps of ints initialized with different hash functions will have different type.

Examples

RES
type t = int
module I0 = unpack(Belt.Id.hashable(~hash=(_: t) => 0xff_ff, ~eq=(a, b) => a == b))
let s0: Belt.HashMap.t<I0.t, int, I0.identity> = Belt.HashMap.make(~hintSize=40, ~id=module(I0))

module I1 = unpack(Belt.Id.hashable(~hash=(_: t) => 0xff, ~eq=(a, b) => a == b))
let s1: Belt.HashMap.t<I1.t, string, I1.identity> = Belt.HashMap.make(~hintSize=40, ~id=module(I1))

The invariant must be held: for two elements who are equal, their hashed value should be the same

Here the compiler would infer s0 and s1 having different type so that it would not mix.

Examples


let s0: t<int, I0.identity>
let s1: t<int, I1.identity>

We can add elements to the collection:

Examples

RES
let () = {
  Belt.HashMap.set(s0, 0, 3)
  Belt.HashMap.set(s1, 1, "3")
}

Since this is an mutable data strucure, s1 will contain two pairs.

clear

RES

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

Clears a hash table.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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

copy

RES

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

Creates copy of a hash map.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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)) == true

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.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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")

forEachU

Deprecated

Use forEach instead

RES

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

Same as forEach but takes uncurried function.

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.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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")]

get

RES

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

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

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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

getBucketHistogram

RES

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

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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)

has

RES

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

Checks if x is bound in tbl.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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

id

RES

type id<'a, 'id> = Belt_Id.hashable<'a, 'id>

The identity needed for making an empty hash map.

isEmpty

RES

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

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

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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

keepMapInPlace

RES

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

Filters out values for which function f returned None.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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))

keepMapInPlaceU

Deprecated

Use keepMapInPlace instead

RES

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

Same as keepMapInPlace but takes uncurried function.

keysToArray

RES

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

Returns array of keys.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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]

logStats

RES

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

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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)

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.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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")

mergeMany

RES

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

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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")])

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.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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")

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

More Examples

RES
Console.log("lol")

reduceU

Deprecated

Use reduce instead

RES

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

remove

RES

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

If bound exists, removes it from the hash map.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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

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.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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"]

size

RES

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

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

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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

t

RES

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

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

toArray

RES

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

Returns array of key value pairs.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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")]

valuesToArray

RES

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

Returns array of values.

Examples

RES
module IntHash = Belt.Id.MakeHashable({
  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"]