HashSet

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.

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

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

clear

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

isEmpty

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

add

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

copy

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

has

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

remove

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

forEachU

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

forEach

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

Order unspecified.

reduceU

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

reduce

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

Order unspecified.

size

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

logStats

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

toArray

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

fromArray

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

mergeMany

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

getBucketHistogram

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