SetDict

t

RE
type t('value, 'identity);

'value is the element type

'identity the identity of the collection

cmp

RE
type cmp('value, 'id) = BeltId.cmp('value, 'id);

Type of compare function.

empty

RE
let empty: t('value, 'id);

RE
let s0 = Belt.Set.Dict.empty;

fromArray

RE
let fromArray: (array('value), ~cmp: cmp('value, 'id)) => t('value, 'id);

Creates new set from array of elements.

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

let s0 = Belt.Set.Dict.fromArray([|1, 3, 2, 4|], ~cmp=IntCmp.cmp);

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

fromSortedArrayUnsafe

RE
let fromSortedArrayUnsafe: array('value) => t('value, 'id);

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

isEmpty

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

Checks if set is empty.

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

let empty = Belt.Set.Dict.fromArray([||], ~cmp=IntCmp.cmp);
let notEmpty = Belt.Set.Dict.fromArray([|1|], ~cmp=IntCmp.cmp);

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

has

RE
let has: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => bool;

Checks if element exists in set.

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

let set = Belt.Set.Dict.fromArray([|1, 4, 2, 5|], ~cmp=IntCmp.cmp);

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

add

RE
let add: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => t('value, 'id);

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

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

let s0 = Belt.Set.Dict.empty;
let s1 = s0->Belt.Set.Dict.add(1, ~cmp=IntCmp.cmp);
let s2 = s1->Belt.Set.Dict.add(2, ~cmp=IntCmp.cmp);
let s3 = s2->Belt.Set.Dict.add(2, ~cmp=IntCmp.cmp);
s0->Belt.Set.Dict.toArray; /* [||] */
s1->Belt.Set.Dict.toArray; /* [|1|] */
s2->Belt.Set.Dict.toArray; /* [|1, 2|] */
s3->Belt.Set.Dict.toArray; /* [|1,2 |] */
s2 == s3; /* true */

mergeMany

RE
let mergeMany: (t('value, 'id), array('value), ~cmp: cmp('value, 'id)) => 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

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

let set = Belt.Set.Dict.empty;

let newSet = set->Belt.Set.Dict.mergeMany([|5, 4, 3, 2, 1|], ~cmp=IntCmp.cmp);
newSet->Belt.Set.Dict.toArray; /* [|1, 2, 3, 4, 5|] */

remove

RE
let remove: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => t('value, 'id);

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

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

let s0 = Belt.Set.Dict.fromArray([|2,3,1,4,5|], ~cmp=IntCmp.cmp);
let s1 = s0->Belt.Set.Dict.remove(1, ~cmp=IntCmp.cmp);
let s2 = s1->Belt.Set.Dict.remove(3, ~cmp=IntCmp.cmp);
let s3 = s2->Belt.Set.Dict.remove(3, ~cmp=IntCmp.cmp);

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

removeMany

RE
let removeMany: (t('value, 'id), array('value), ~cmp: cmp('value, 'id)) => 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.

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

let set = Belt.Set.Dict.fromArray([|1, 2, 3, 4|],~cmp=IntCmp.cmp);

let newSet = set->Belt.Set.Dict.removeMany([|5, 4, 3, 2, 1|], ~cmp=IntCmp.cmp);
newSet->Belt.Set.Dict.toArray; /* [||] */

union

RE
let union: (t('value, 'id), t('value, 'id), ~cmp: cmp('value, 'id)) => t('value, 'id);

Returns union of two sets.

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

let s0 = Belt.Set.Dict.fromArray([|5,2,3,5,6|], ~cmp=IntCmp.cmp);
let s1 = Belt.Set.Dict.fromArray([|5,2,3,1,5,4|], ~cmp=IntCmp.cmp);
let union = Belt.Set.Dict.union(s0, s1, ~cmp=IntCmp.cmp);
union->Belt.Set.Dict.toArray; /* [|1,2,3,4,5,6|] */

intersect

RE
let intersect: (t('value, 'id), t('value, 'id), ~cmp: cmp('value, 'id)) => t('value, 'id);

Returns intersection of two sets.

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

let s0 = Belt.Set.Dict.fromArray([|5,2,3,5,6|], ~cmp=IntCmp.cmp);
let s1 = Belt.Set.Dict.fromArray([|5,2,3,1,5,4|], ~cmp=IntCmp.cmp);
let intersect = Belt.Set.Dict.intersect(s0, s1, ~cmp=IntCmp.cmp);
intersect->Belt.Set.Dict.toArray; /* [|2,3,5|] */

diff

RE
let diff: (t('value, 'id), t('value, 'id), ~cmp: cmp('value, 'id)) => t('value, 'id);

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

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

let s0 = Belt.Set.Dict.fromArray([|5,2,3,5,6|], ~cmp=IntCmp.cmp);
let s1 = Belt.Set.Dict.fromArray([|5,2,3,1,5,4|], ~cmp=IntCmp.cmp);

let diff1 = Belt.Set.Dict.diff(s0, s1, ~cmp=IntCmp.cmp);
let diff2 = Belt.Set.Dict.diff(s1,s0, ~cmp=IntCmp.cmp);

diff1->Belt.Set.Dict.toArray; /* [|6|] */
diff2->Belt.Set.Dict.toArray; /* [|1,4|] */

subset

RE
let subset: (t('value, 'id), t('value, 'id), ~cmp: cmp('value, 'id)) => bool;

Checks if second set is subset of first set.

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

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

cmp

RE
let cmp: (t('value, 'id), t('value, 'id), ~cmp: cmp('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

RE
let eq: (t('value, 'id), t('value, 'id), ~cmp: cmp('value, 'id)) => bool;

Checks if two sets are equal.

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

let s0 = Belt.Set.Dict.fromArray([|5,2,3|], ~cmp=IntCmp.cmp);
let s1 = Belt.Set.Dict.fromArray([|3,2,5|], ~cmp=IntCmp.cmp);

Belt.Set.Dict.eq(s0, s1, ~cmp=IntCmp.cmp); /* true */

forEachU

RE
let forEachU: (t('value, 'id), [@bs] ('value => unit)) => unit;

Same as forEach but takes uncurried functon.

forEach

RE
let forEach: (t('value, 'id), 'value => unit) => unit;

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

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

let s0 = Belt.Set.Dict.fromArray([|5,2,3,5,6|], ~cmp=IntCmp.cmp);
let acc = ref([]);
s0->Belt.Set.Dict.forEach(x => {
  acc := Belt.List.add(acc^, x)
});
acc; /* [6,5,3,2] */

reduceU

RE
let reduceU: (t('value, 'id), 'a, [@bs] (('a, 'value) => 'a)) => 'a;

reduce

RE
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.

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

let s0 = Belt.Set.Dict.fromArray([|5,2,3,5,6|], ~cmp=IntCmp.cmp);
s0->Belt.Set.Dict.reduce([], (acc, element) =>
  acc->Belt.List.add(element)
); /* [6,5,3,2] */

everyU

RE
let everyU: (t('value, 'id), [@bs] ('value => bool)) => bool;

every

RE
let every: (t('value, 'id), 'value => bool) => bool;

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

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

let isEven = x => x mod 2 == 0;

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

someU

RE
let someU: (t('value, 'id), [@bs] ('value => bool)) => bool;

some

RE
let some: (t('value, 'id), 'value => bool) => bool;

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

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

let isOdd = x => x mod 2 != 0;

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

keepU

RE
let keepU: (t('value, 'id), [@bs] ('value => bool)) => t('value, 'id);

keep

RE
let keep: (t('value, 'id), 'value => bool) => t('value, 'id);

Returns the set of all elements that satisfy the predicate.

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

let isEven = x => x mod 2 == 0;

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

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

partitionU

RE
let partitionU: (t('value, 'id), [@bs] ('value => bool)) => (t('value, 'id), t('value, 'id));

partition

RE
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.

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

let isOdd = x => x mod 2 != 0;

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

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

size

RE
let size: t('value, 'id) => int;

Returns size of the set.

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

let s0 = Belt.Set.Dict.fromArray([|1,2,3,4|], ~cmp=IntCmp.cmp);

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

toList

RE
let toList: t('value, 'id) => list('value);

Returns list of ordered set elements.

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

let s0 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);

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

toArray

RE
let toArray: t('value, 'id) => array('value);

Returns array of ordered set elements.

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

let s0 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);

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

minimum

RE
let minimum: t('value, 'id) => option('value);

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

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

let s0 = Belt.Set.Dict.empty;
let s1 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);

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

minUndefined

RE
let minUndefined: t('value, 'id) => Js.undefined('value);

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

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

let s0 = Belt.Set.Dict.empty;
let s1 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);

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

maximum

RE
let maximum: t('value, 'id) => option('value);

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

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

let s0 = Belt.Set.Dict.empty;
let s1 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);

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

maxUndefined

RE
let maxUndefined: t('value, 'id) => Js.undefined('value);

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

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

let s0 = Belt.Set.Dict.empty;
let s1 = Belt.Set.Dict.fromArray([|3,2,1,5|], ~cmp=IntCmp.cmp);

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

get

RE
let get: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => 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.

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

let s0 = Belt.Set.Dict.fromArray([|1,2,3,4,5|], ~cmp=IntCmp.cmp);

s0->Belt.Set.Dict.get(3, ~cmp=IntCmp.cmp); /* Some(3) */
s0->Belt.Set.Dict.get(20, ~cmp=IntCmp.cmp); /* None */

getUndefined

RE
let getUndefined: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => Js.undefined('value);

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

getExn

RE
let getExn: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => 'value;

Same as get but raise when element does not exist.

split

RE
let split: (t('value, 'id), 'value, ~cmp: cmp('value, 'id)) => ((t('value, 'id), t('value, 'id)), bool);

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

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

let s0 = Belt.Set.Dict.fromArray([|1,2,3,4,5|], ~cmp=IntCmp.cmp);

let ((smaller, larger), present) =
  s0->Belt.Set.Dict.split(3, ~cmp=IntCmp.cmp);

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

checkInvariantInternal

RE
let checkInvariantInternal: t('a, 'b) => unit;

raise when invariant is not held