You are currently looking at the < v8.2.0 docs (Reason v3.6 syntax edition). You can find the latest API docs here.
(These docs cover all versions between v3 to v8 and are equivalent to the old BuckleScript docs before the rebrand)
SetString
Specalized when value type is string
, more efficient than the generic type, its compare behavior is fixed using the built-in comparison.
value
type value = string;
The type of the set elements.
t
type t;
The type of sets.
empty
let empty: t;
Empty set
RElet s0 = Belt.Set.String.empty;
fromArray
let fromArray: array(value) => t;
Creates new set from array of elements.
RElet s0 = Belt.Set.String.fromArray([|"apple", "orange", "banana"|])
s0->Belt.Set.String.toArray; /* [|"apple", "banana", "orange"|] */
fromSortedArrayUnsafe
let fromSortedArrayUnsafe: array(value) => t;
The same as [fromArray][#fromarray] except it is after assuming the input array is already sorted.
isEmpty
let isEmpty: t => bool;
Checks if set is empty.
RElet empty = Belt.Set.String.fromArray([||]);
let notEmpty = Belt.Set.String.fromArray([|"apple"|]);
Belt.Set.String.isEmpty(empty); /* true */
Belt.Set.String.isEmpty(notEmpty); /* false */
has
let has: (t, value) => bool;
Checks if element exists in set.
RElet set = Belt.Set.String.fromArray([|"apple", "orange", "banana"|]);
set->Belt.Set.String.has("strawberry") /* false */
set->Belt.Set.String.has("apple") /* true */
add
let add: (t, value) => t;
Adds element to set. If element existed in set, value is unchanged.
RElet s0 = Belt.Set.String.empty;
let s1 = s0->Belt.Set.String.add("apple");
let s2 = s1->Belt.Set.String.add("banana");
let s3 = s2->Belt.Set.String.add("banana");
s0->Belt.Set.String.toArray; /* [||] */
s1->Belt.Set.String.toArray; /* [|"apple"|] */
s2->Belt.Set.String.toArray; /* [|"apple", "banana"|] */
s3->Belt.Set.String.toArray; /* [|"apple", "banana"|] */
s2 == s3; /* true */
mergeMany
let mergeMany: (t, array(value)) => t;
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
RElet set = Belt.Set.String.empty;
let newSet =
set->Belt.Set.String.mergeMany([|"apple", "banana", "orange", "strawberry"|]);
newSet->Belt.Set.String.toArray; /* [|"apple", "banana", "orange", "strawberry"|] */
remove
let remove: (t, value) => t;
Removes element from set. If element wasn't existed in set, value is unchanged.
RElet s0 = Belt.Set.String.fromArray([|"orange", "banana", "apple"|]);
let s1 = s0->Belt.Set.String.remove("apple");
let s2 = s1->Belt.Set.String.remove("banana");
let s3 = s2->Belt.Set.String.remove("banana");
s1->Belt.Set.String.toArray; /* [|"orange", "banana"|] */
s2->Belt.Set.String.toArray; /* [|"orange"|] */
s2 == s3; /* true */
removeMany
let removeMany: (t, array(value)) => t;
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.
RElet set = Belt.Set.String.fromArray([|"apple", "banana", "orange"|]);
let newSet = set->Belt.Set.String.removeMany([|"strawberry", "apple", "banana", "orange"|]);
newSet->Belt.Set.String.toArray; /* [||] */
union
let union: (t, t) => t;
Returns union of two sets.
RElet s0 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "carrot"|]);
let s1 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "strawberry"|]);
let union = Belt.Set.String.union(s0, s1);
union->Belt.Set.String.toArray; /* [|"apple", "banana", "carrot", "orange", "strawberry"|] */
intersect
let intersect: (t, t) => t;
Returns intersection of two sets.
RElet s0 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "carrot"|]);
let s1 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "strawberry"|]);
let intersect = Belt.Set.String.intersect(s0, s1);
intersect->Belt.Set.String.toArray; /* [|"apple", "banana", "orange"|] */
diff
let diff: (t, t) => t;
Returns elements from first set, not existing in second set.
RElet s0 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "carrot"|]);
let s1 = Belt.Set.String.fromArray([|"apple", "banana", "orange", "strawberry"|]);
Belt.Set.String.toArray(Belt.Set.String.diff(s0, s1)); /* [|"carrot"|] */
Belt.Set.String.toArray(Belt.Set.String.diff(s1, s0)); /* [|"strawberry"|] */
subset
let subset: (t, t) => bool;
Checks if second set is subset of first set.
RElet s0 = Belt.Set.String.fromArray([|"5", "2", "3", "5", "6"|]);
let s1 = Belt.Set.String.fromArray([|"5", "2", "3", "1", "5", "4"|]);
let s2 = Belt.Set.String.intersect(s0, s1);
Belt.Set.String.subset(s2, s0); /* true */
Belt.Set.String.subset(s2, s1); /* true */
Belt.Set.String.subset(s1, s0); /* false */
cmp
let cmp: (t, t) => 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
let eq: (t, t) => bool;
Checks if two sets are equal.
RElet s0 = Belt.Set.String.fromArray([|"apple", "orange"|]);
let s1 = Belt.Set.String.fromArray([|"orange", "apple"|]);
Belt.Set.String.eq(s0, s1); /* true */
forEachU
let forEachU: (t, [@bs] (value => unit)) => unit;
Same as forEach but takes uncurried functon.
forEach
let forEach: (t, value => unit) => unit;
Applies function f
in turn to all elements of set in increasing order.
RElet s0 = Belt.Set.String.fromArray([|"banana", "orange", "apple"|]);
let acc = ref([]);
s0->Belt.Set.String.forEach(x => {
acc := Belt.List.add(acc^, x)
});
acc; /* ["orange", "banana", "apple"] */
reduceU
let reduceU: (t, 'a, [@bs] (('a, value) => 'a)) => 'a;
reduce
let reduce: (t, '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.
RElet s0 = Belt.Set.String.fromArray([|"apple", "orange"|]);
s0->Belt.Set.String.reduce(0, (acc, element) =>
acc + String.length(element)
); /* 11 */
everyU
let everyU: (t, [@bs] (value => bool)) => bool;
every
let every: (t, value => bool) => bool;
Checks if all elements of the set satisfy the predicate. Order unspecified.
RElet hasAtLeastFiveChars = x => String.length(x) >= 5;
let s0 = Belt.Set.String.fromArray([|"apple", "carrot"|]);
s0->Belt.Set.String.every(hasAtLeastFiveChars); /* true */
someU
let someU: (t, [@bs] (value => bool)) => bool;
some
let some: (t, value => bool) => bool;
Checks if at least one element of the set satisfies the predicate.
RElet hasFiveChars = x => String.length(x) == 5;
let s0 = Belt.Set.String.fromArray([|"strawberry", "apple"|]);
s0->Belt.Set.String.some(hasFiveChars); /* true */
keepU
let keepU: (t, [@bs] (value => bool)) => t;
keep
let keep: (t, value => bool) => t;
Returns the set of all elements that satisfy the predicate.
RElet hasFiveChars = x => String.length(x) == 5;
let s0 = Belt.Set.String.fromArray([|"apple", "orange", "banana"|]);
let s1 = s0->Belt.Set.String.keep(hasFiveChars);
s1->Belt.Set.String.toArray; /* [|"apple"|] */
partitionU
let partitionU: (t, [@bs] (value => bool)) => (t, t);
partition
let partition: (t, value => bool) => (t, t);
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.
RElet hasFiveChars = x => String.length(x) == 5;
let s0 = Belt.Set.String.fromArray([|"apple", "carrot"|]);
let (s1, s2) = s0->Belt.Set.String.partition(hasFiveChars);
s1->Belt.Set.String.toArray; /* [|"apple"|] */
s2->Belt.Set.String.toArray; /* [|"carrot"|] */
size
let size: t => int;
Returns size of the set.
RElet s0 = Belt.Set.String.fromArray([|"apple"|]);
s0->Belt.Set.String.size; /* 1 */
toList
let toList: t => list(value);
Returns list of ordered set elements.
RElet s0 = Belt.Set.String.fromArray([|"apple", "watermelon"|]);
s0->Belt.Set.String.toList; /* ["apple", "watermelon"] */
toArray
let toArray: t => array(value);
Returns array of ordered set elements.
RElet s0 = Belt.Set.String.fromArray([|"apple", "watermelon"|]);
s0->Belt.Set.String.toArray; /* [|"apple", "watermelon"|] */
minimum
let minimum: t => option(value);
Returns minimum value of the collection. None
if collection is empty.
RElet s0 = Belt.Set.String.empty;
let s1 = Belt.Set.String.fromArray([|"apple", "orange"|]);
s0->Belt.Set.String.minimum; /* None */
s1->Belt.Set.String.minimum; /* Some("apple") */
minUndefined
let minUndefined: t => Js.undefined(value);
Returns minimum value of the collection. undefined
if collection is empty.
RElet s0 = Belt.Set.String.empty;
let s1 = Belt.Set.String.fromArray([|"apple", "orange"|]);
s0->Belt.Set.String.minUndefined; /* undefined */
s1->Belt.Set.String.minUndefined; /* "apple" */
maximum
let maximum: t => option(value);
Returns maximum value of the collection. None
if collection is empty.
RElet s0 = Belt.Set.String.empty;
let s1 = Belt.Set.String.fromArray([|"apple", "orange"|]);
s0->Belt.Set.String.maximum; /* None */
s1->Belt.Set.String.maximum; /* Some("orange") */
maxUndefined
let maxUndefined: t => Js.undefined(value);
Returns maximum value of the collection. undefined
if collection is empty.
RElet s0 = Belt.Set.String.empty;
let s1 = Belt.Set.String.fromArray([|"apple", "orange"|]);
s0->Belt.Set.String.maxUndefined; /* undefined */
s1->Belt.Set.String.maxUndefined; /* orange */
get
let get: (t, 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.
RElet s0 = Belt.Set.String.fromArray([|"apple", "carrot"|]);
s0->Belt.Set.String.get("carrot"); /* Some("carrot") */
s0->Belt.Set.String.get("watermelon"); /* None */
getUndefined
let getUndefined: (t, value) => Js.undefined(value);
See get - returns undefined
when element does not exist.
getExn
let getExn: (t, value) => value;
See get - raise when element does not exist.
split
let split: (t, value) => ((t, t), bool);
Returns a triple ((l, r), present)
, where l
is the set of elements of set that are strictly less than value, r
is the set of elements of set that are strictly greater than value, present
is false
if set contains no element equal to value, or true
if set contains an element equal to value.
RElet s0 = Belt.Set.String.fromArray([|"apple", "banana", "orange"|]);
let ((smaller, larger), present) = s0->Belt.Set.String.split("banana");
present; /* true */
smaller->Belt.Set.String.toArray; /* [|"apple"|] */
larger->Belt.Set.String.toArray; /* [|"orange"|] */
checkInvariantInternal
let checkInvariantInternal: t => unit;
raise when invariant is not held