Set.Dict
This module seprate identity from data, it is a bit more verboe but slightly more efficient due to the fact that there is no need to pack identity and data back after each operation
let empty: t('value, 'id);
let fromSortedArrayUnsafe: array('value) => t('value, 'id);
let isEmpty: t(_, _) => bool;
add s x
If x
was already in s
, s
is returned unchanged.
remove m x
If x
was not in m
, m
is returned reference unchanged.
subset s1 s2
tests whether the set s1
is a subset of the set s2
.
Total ordering between sets. Can be used as the ordering function for doing sets of sets.
eq s1 s2
tests whether the sets s1
and s2
are equal, that is, contain equal elements.
let forEachU: t('value, 'id) => Js.Fn.arity1(('value => unit)) => unit;
let forEach: t('value, 'id) => ('value => unit) => unit;
forEach s f
applies f
in turn to all elements of s
. In increasing order
let reduceU: t('value, 'id) => 'a => Js.Fn.arity2(('a => 'value => 'a)) => 'a;
let reduce: t('value, 'id) => 'a => ('a => 'value => 'a) => 'a;
Iterate in increasing order.
let everyU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => bool;
let every: t('value, 'id) => ('value => bool) => bool;
every p s
checks if all elements of the set satisfy the predicate p
. Order unspecified.
let someU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => bool;
let some: t('value, 'id) => ('value => bool) => bool;
some p s
checks if at least one element of the set satisfies the predicate p
. Oder unspecified.
let keepU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => t('value, 'id);
keep p s
returns the set of all elements in s
that satisfy predicate p
.
let partitionU:
t('value, 'id) =>
Js.Fn.arity1(('value => bool)) =>
(t('value, 'id), t('value, 'id));
partition p s
returns a pair of sets (s1, s2)
, where s1
is the set of all the elements of s
that satisfy the predicate p
, and s2
is the set of all the elements of s
that do not satisfy p
.
let size: t('value, 'id) => int;
let toList: t('value, 'id) => list('value);
In increasing order
let toArray: t('value, 'id) => array('value);
let minimum: t('value, 'id) => option('value);
let minUndefined: t('value, 'id) => Js.undefined('value);
let maximum: t('value, 'id) => option('value);
let maxUndefined: t('value, 'id) => Js.undefined('value);
let getUndefined:
t('value, 'id) =>
'value =>
cmp:cmp('value, 'id) =>
Js.undefined('value);
let split:
t('value, 'id) =>
'value =>
cmp:cmp('value, 'id) =>
((t('value, 'id), t('value, 'id)), bool);
split x s
returns a triple (l, present, r)
, where l
is the set of elements of s
that are strictly less than x
; r
is the set of elements of s
that are strictly greater than x
; present
is false
if s
contains no element equal to x
, or true
if s
contains an element equal to x
.
let checkInvariantInternal: t(_, _) => unit;
raise when invariant is not held