API / Belt / HashSet

HashSet

A mutable Hash set 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 HashSets of ints initialized with different hash functions will have different type.

RES
module I0 = unpack(
  Belt.Id.hashableU(
    ~hash=(. a: int) => land(a, 65535),
    ~eq=(. a, b) => a == b,
  )
)

let s0 = Belt.HashSet.make(~id=module(I0), ~hintSize=40)

module I1 = unpack(
  Belt.Id.hashableU(
    ~hash=(. a: int) => land(a, 255),
    ~eq=(. a, b) => a == b,
  )
)

let s1 = Belt.HashSet.make(~id=module(I1), ~hintSize=40)

Belt.HashSet.add(s1, 0)
Belt.HashSet.add(s1, 1)

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.

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

We can add elements to the collection (see last two lines in the example above). Since this is an mutable data structure, s1 will contain two pairs.

t

RES
type t<'a, 'id>

id

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

make

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

clear

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

isEmpty

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

add

RES
let add: (t<'a, 'id>, 'a) => unit

copy

RES
let copy: t<'a, 'id> => t<'a, 'id>

has

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

remove

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

forEachU

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

forEach

RES
let forEach: (t<'a, 'id>, 'a => unit) => unit

Order unspecified.

reduceU

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

reduce

RES
let reduce: (t<'a, 'id>, 'c, ('c, 'a) => 'c) => 'c

Order unspecified.

size

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

logStats

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

toArray

RES
let toArray: t<'a, 'id> => array<'a>

fromArray

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

mergeMany

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

getBucketHistogram

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