API / Belt / Set

Set

A immutable sorted set module which allows customize compare behavior. The implementation uses balanced binary trees, and therefore searching and insertion take time logarithmic in the size of the map.

It also has three specialized inner modules Belt.Set.Int, Belt.Set.String and Belt.Set.Dict - This module separates data from function which is more verbose but slightly more efficient

RES
module PairComparator =
  Belt.Id.MakeComparableU({
    type t = (int, int)
    let cmp = ((a0, a1), (b0, b1)) =>
      switch (Pervasives.compare(a0, b0)) {
      | 0 => Pervasives.compare(a1, b1)
      | c => c
      }
  })

let mySet = Belt.Set.make(~id=module(PairComparator))
let mySet2 = Belt.Set.add(mySet, (1, 2))

Note: This module's examples will assume a predeclared module for integers called IntCmp. It is declared like this:

RES
module IntCmp =
  Belt.Id.MakeComparable({
    type t = int
    let cmp = Pervasives.compare
  })

t

RES
type t<'value, 'identity>

'value is the element type

'identity the identity of the collection

id

RES
type id<'value, 'id> = Belt_Id.comparable<'value, 'id>

The identity needed for making a set from scratch

make

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

Creates a new set by taking in the comparator

RES
let set = Belt.Set.make(~id=module(IntCmp))

fromArray

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

Creates new set from array of elements.

RES
let s0 = Belt.Set.fromArray([1, 3, 2, 4], ~id=module(IntCmp))

s0->Belt.Set.toArray /* [1, 2, 3, 4] */

fromSortedArrayUnsafe

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

The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.

isEmpty

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

Checks if set is empty.

RES
let empty = Belt.Set.fromArray([], ~id=module(IntCmp))
let notEmpty = Belt.Set.fromArray([1],~id=module(IntCmp))

Belt.Set.isEmpty(empty) /* true */
Belt.Set.isEmpty(notEmpty) /* false */

has

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

Checks if element exists in set.

RES
let set = Belt.Set.fromArray([1, 4, 2, 5], ~id=module(IntCmp))

set->Belt.Set.has(3) /* false */
set->Belt.Set.has(1) /* true */

add

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

Adds element to set. If element existed in set, value is unchanged.

RES
let s0 = Belt.Set.make(~id=module(IntCmp))
let s1 = s0->Belt.Set.add(1)
let s2 = s1->Belt.Set.add(2)
let s3 = s2->Belt.Set.add(2)
s0->Belt.Set.toArray /* [] */
s1->Belt.Set.toArray /* [1] */
s2->Belt.Set.toArray /* [1, 2] */
s3->Belt.Set.toArray /* [1,2 ] */
s2 == s3 /* true */

mergeMany

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

Adds each element of array to set. Unlike add, the reference of return value might be changed even if all values in array already exist in set

RES
let set = Belt.Set.make(~id=module(IntCmp))

let newSet = set->Belt.Set.mergeMany([5, 4, 3, 2, 1])
newSet->Belt.Set.toArray /* [1, 2, 3, 4, 5] */

remove

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

Removes element from set. If element wasn't existed in set, value is unchanged.

RES
let s0 = Belt.Set.fromArray([2,3,1,4,5], ~id=module(IntCmp))
let s1 = s0->Belt.Set.remove(1)
let s2 = s1->Belt.Set.remove(3)
let s3 = s2->Belt.Set.remove(3)

s1->Belt.Set.toArray /* [2,3,4,5] */
s2->Belt.Set.toArray /* [2,4,5] */
s2 == s3 /* true */

removeMany

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

Removes each element of array from set. Unlike remove, the reference of return value might be changed even if any values in array not existed in set.

RES
let set = Belt.Set.fromArray([1, 2, 3, 4],~id=module(IntCmp))

let newSet = set->Belt.Set.removeMany([5, 4, 3, 2, 1])
newSet->Belt.Set.toArray /* [] */

union

RES
let union: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>

Returns union of two sets.

RES
let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
let union = Belt.Set.union(s0, s1)
union->Belt.Set.toArray /* [1,2,3,4,5,6] */

intersect

RES
let intersect: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>

Returns intersection of two sets.

RES
let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
let intersect = Belt.Set.intersect(s0, s1)
intersect->Belt.Set.toArray /* [2,3,5] */

diff

RES
let diff: (t<'value, 'id>, t<'value, 'id>) => t<'value, 'id>

Returns elements from first set, not existing in second set.

RES
let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
Belt.Set.toArray(Belt.Set.diff(s0, s1)) /* [6] */
Belt.Set.toArray(Belt.Set.diff(s1,s0)) /* [1,4] */

subset

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

Checks if second set is subset of first set.

RES
let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
let s1 = Belt.Set.fromArray([5,2,3,1,5,4], ~id=module(IntCmp))
let s2 = Belt.Set.intersect(s0, s1)
Belt.Set.subset(s2, s0) /* true */
Belt.Set.subset(s2, s1) /* true */
Belt.Set.subset(s1, s0) /* false */

cmp

RES
let cmp: (t<'value, 'id>, t<'value, 'id>) => int

Total ordering between sets. Can be used as the ordering function for doing sets of sets. It compares size first and then iterates over each element following the order of elements.

eq

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

Checks if two sets are equal.

RES
let s0 = Belt.Set.fromArray([5,2,3], ~id=module(IntCmp))
let s1 = Belt.Set.fromArray([3,2,5], ~id=module(IntCmp))

Belt.Set.eq(s0, s1) /* true */

forEachU

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

Same as forEach but takes uncurried functon.

forEach

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

Applies function f in turn to all elements of set in increasing order.

RES
let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
let acc = ref(list{})
s0->Belt.Set.forEach(x => {
  acc := Belt.List.add(acc.contents, x)
})
acc /* [6,5,3,2] */

reduceU

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

reduce

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

Applies function f to each element of set in increasing order. Function f has two parameters: the item from the set and an “accumulator”, which starts with a value of initialValue. reduce returns the final value of the accumulator.

RES
let s0 = Belt.Set.fromArray([5,2,3,5,6], ~id=module(IntCmp))
s0->Belt.Set.reduce(list{}, (acc, element) =>
  acc->Belt.List.add(element)
) /* [6,5,3,2] */

everyU

RES
let everyU: (t<'value, 'id>, (. 'value) => bool) => bool

every

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

Checks if all elements of the set satisfy the predicate. Order unspecified.

RES
let isEven = x => mod(x, 2) == 0

let s0 = Belt.Set.fromArray([2,4,6,8], ~id=module(IntCmp))
s0->Belt.Set.every(isEven) /* true */

someU

RES
let someU: (t<'value, 'id>, (. 'value) => bool) => bool

some

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

Checks if at least one element of the set satisfies the predicate.

RES
let isOdd = x => mod(x, 2) != 0

let s0 = Belt.Set.fromArray([1,2,4,6,8], ~id=module(IntCmp))
s0->Belt.Set.some(isOdd) /* true */

keepU

RES
let keepU: (t<'value, 'id>, (. 'value) => bool) => t<'value, 'id>

keep

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

Returns the set of all elements that satisfy the predicate.

RES
let isEven = x => mod(x, 2) == 0

let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))
let s1 = s0->Belt.Set.keep(isEven)

s1->Belt.Set.toArray /* [2,4] */

partitionU

RES
let partitionU: (t<'value, 'id>, (. 'value) => bool) => (t<'value, 'id>, t<'value, 'id>)

partition

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

Returns a pair of sets, where first is the set of all the elements of set that satisfy the predicate, and second is the set of all the elements of set that do not satisfy the predicate.

RES
let isOdd = x => mod(x, 2) != 0

let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))
let (s1, s2) = s0->Belt.Set.partition(isOdd)

s1->Belt.Set.toArray /* [1,3,5] */
s2->Belt.Set.toArray /* [2,4] */

size

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

Returns size of the set.

RES
let s0 = Belt.Set.fromArray([1,2,3,4], ~id=module(IntCmp))

s0->Belt.Set.size /* 4 */

toArray

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

Returns array of ordered set elements.

RES
let s0 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))

s0->Belt.Set.toArray /* [1,2,3,5] */

toList

RES
let toList: t<'value, 'id> => list<'value>

Returns list of ordered set elements.

RES
let s0 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))

s0->Belt.Set.toList /* [1,2,3,5] */

minimum

RES
let minimum: t<'value, 'id> => option<'value>

Returns minimum value of the collection. None if collection is empty.

RES
let s0 = Belt.Set.make(~id=module(IntCmp))
let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))

s0->Belt.Set.minimum /* None */
s1->Belt.Set.minimum /* Some(1) */

minUndefined

RES
let minUndefined: t<'value, 'id> => Js.undefined<'value>

Returns minimum value of the collection. undefined if collection is empty.

RES
let s0 = Belt.Set.make(~id=module(IntCmp))
let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))

s0->Belt.Set.minUndefined /* undefined */
s1->Belt.Set.minUndefined /* 1 */

maximum

Returns maximum value of the collection. None if collection is empty.

RES
let s0 = Belt.Set.make(~id=module(IntCmp))
let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))

s0->Belt.Set.maximum /* None */
s1->Belt.Set.maximum /* Some(5) */

maxUndefined

RES
let maxUndefined: t<'value, 'id> => Js.undefined<'value>

Returns maximum value of the collection. undefined if collection is empty.

RES
let s0 = Belt.Set.make(~id=module(IntCmp))
let s1 = Belt.Set.fromArray([3,2,1,5], ~id=module(IntCmp))

s0->Belt.Set.maxUndefined /* undefined */
s1->Belt.Set.maxUndefined /* 5 */

get

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

Returns the reference of the value which is equivalent to value using the comparator specifiecd by this collection. Returns None if element does not exist.

RES
let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))

s0->Belt.Set.get(3) /* Some(3) */
s0->Belt.Set.get(20) /* None */

getUndefined

RES
let getUndefined: (t<'value, 'id>, 'value) => Js.undefined<'value>

Same as get but returns undefined when element does not exist.

getExn

RES
let getExn: (t<'value, 'id>, 'value) => 'value

Same as get but raise when element does not exist.

split

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

Returns a tuple ((smaller, larger), present), present is true when element exist in set.

RES
let s0 = Belt.Set.fromArray([1,2,3,4,5], ~id=module(IntCmp))

let ((smaller, larger), present) = s0->Belt.Set.split(3)

present /* true */
smaller->Belt.Set.toArray /* [1,2] */
larger->Belt.Set.toArray /* [4,5] */

getData

RES
let getData: t<'value, 'id> => Belt_SetDict.t<'value, 'id>

Advanced usage only

Returns the raw data (detached from comparator), but its type is still manifested, so that user can pass identity directly without boxing.

getId

RES
let getId: t<'value, 'id> => id<'value, 'id>

Advanced usage only

Returns the identity of set.

packIdData

RES
let packIdData: (~id: id<'value, 'id>, ~data: Belt_SetDict.t<'value, 'id>) => t<'value, 'id>

Advanced usage only

Returns the packed collection.