HashMapInt

key

type key = int;

Type of the Belt.HashMap.Int key.

t

type t('b);

Type of the Belt.HashMap.Int

make

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

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

RE

let hMap = Belt.HashMap.Int.make(~hintSize=10);

Belt.HashMap.Int.set(hMap, 1, "a");

clear

let clear: t('b) => unit;

Clears a hash table.

RE
let hMap = Belt.HashMap.Int.fromArray([|(1, "1")|])  
Belt.HashMap.Int.clear(hMap)
Belt.HashMap.Int.isEmpty(hMap) == true;

isEmpty

let isEmpty: t('a) => bool;

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

RE
let hMap = Belt.HashMap.Int.fromArray([|(1, "1")|])  
Belt.HashMap.Int.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.

RE
 
let hMap = Belt.HashMap.Int.fromArray([|(2, "2")|]);

Belt.HashMap.Int.set(hMap, 1, "1");

Belt.HashMap.Int.valuesToArray(hMap) == [|"1", "2"|];

copy

let copy: t('a) => t('a);

Creates copy of a hash map.

RE
let hMap1 = Belt.HashMap.Int.fromArray([|(1, "1"), (2, "2")|]);
let hMap2 = Belt.HashMap.Int.copy(hMap1)

Belt.HashMap.Int.set(hMap2, 2, "3");

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

get

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

has

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

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

RE
let hMap = Belt.HashMap.Int.make(~hintSize=10);
Belt.HashMap.Int.set(hMap, 1, "value1");

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

remove

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

If bound exists, removes it from the hash map.

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

forEachU

let forEachU: (t('b), [@bs] ((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.

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

reduceU

let reduceU: (t('b), 'c, [@bs] (('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.

RE
let hMap = Belt.HashMap.Int.make(~hintSize=10);
Belt.HashMap.Int.set(hMap, 1, "value1");
Belt.HashMap.Int.set(hMap, 2, "value2");

Belt.HashMap.Int.reduce(hMap, "", (acc, key, value) => {
  acc ++ ", " ++ value
}) == "value1, value2";

keepMapInPlaceU

let keepMapInPlaceU: (t('a), [@bs] ((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.

RE
let hMap = Belt.HashMap.Int.make(~hintSize=10);
Belt.HashMap.Int.set(hMap, 1, "value1");
Belt.HashMap.Int.set(hMap, 2, "value2");

Belt.HashMap.Int.keepMapInPlace(hMap, (key, value) => {
  key mod 1 == 0 ? None : Some(value)
});

size

let size: t('a) => int;

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

RE
let hMap = Belt.HashMap.Int.make(~hintSize=10);
Belt.HashMap.Int.set(hMap, 1, "value1");
Belt.HashMap.Int.set(hMap, 2, "value2");

Belt.HashMap.Int.size(hMap) == 2;

toArray

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

Returns array of key value pairs.

RE
let hMap = Belt.HashMap.Int.make(~hintSize=10);
Belt.HashMap.Int.set(hMap, 1, "value1");
Belt.HashMap.Int.set(hMap, 2, "value2");

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

keysToArray

let keysToArray: t('a) => array(key);

Returns array of keys.

RE
let hMap = Belt.HashMap.Int.make(~hintSize=10);
Belt.HashMap.Int.set(hMap, 1, "value1");
Belt.HashMap.Int.set(hMap, 2, "value2");

Belt.HashMap.Int.keysToArray(hMap) == [|1, 2|];

valuesToArray

let valuesToArray: t('a) => array('a);

Returns array of values.

RE
let hMap = Belt.HashMap.Int.make(~hintSize=10);
Belt.HashMap.Int.set(hMap, 1, "value1");
Belt.HashMap.Int.set(hMap, 2, "value2");

Belt.HashMap.Int.valuesToArray(hMap) == [|"value1", "value2"|];

fromArray

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

Creates new hash map from array of pairs.

Returns array of values.

RE
let hMap = Belt.HashMap.Int.fromArray([|(1, "value1"), (1, "value2")|]);
Belt.HashMap.Int.toArray(hMap) == [|(1, "value1"), (2, "value2")|];

mergeMany

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

Merges many key value pairs into hash map.

RE
let hMap = Belt.HashMap.Int.make(~hintSize=10);
Belt.HashMap.Int.mergeMany(hMap, [|(1, "value1"), (2, "value2")|]);

getBucketHistogram

let getBucketHistogram: t('a) => array(int);

RE
let hMap = Belt.HashMap.Int.make(~hintSize=10);
Belt.HashMap.Int.set(hMap, 1, "1");

Belt.HashMap.Int.getBucketHistogram(hMap);

logStats

let logStats: t('a) => unit;

RE
let hMap = Belt.HashMap.Int.make(~hintSize=10);
Belt.HashMap.Int.set(hMap, 1, "1");

Belt.HashMap.Int.logStats(hMap);