The type of elements of the set

Alias for the type of elements, for cross-compatibility with maps

Underlying basemap, for cross map/set operations

The set type

The empty set

is_empty st is true if st contains no elements, false otherwise

mem elt set is true if elt is contained in set, O(log(n)) complexity.

add elt set adds element elt to the set. Preserves physical equality if elt was already present. O(log(n)) complexity.

singleton elt returns a set containing a single element: elt

cardinal set is the size of the set (number of elements), O(n) complexity.

is_singleton set is Some (Any elt) if set is singleton elt and None otherwise. O(1) complexity.

remove elt set returns a set containing all elements of set except elt. Returns a value physically equal to set if elt is not present.

The minimal element (according to the unsigned order on KEY.to_int) if non empty.

• raises Not_found

The maximal element (according to the unsigned order on KEY.to_int) if non empty.

• raises Not_found

pop_unsigned_minimum s is Some (elt, s') where elt = unsigned_min_elt s and s' = remove elt s if s is non empty. Uses the unsigned order on KEY.to_int.

pop_unsigned_maximum s is Some (elt, s') where elt = unsigned_max_elt s and s' = remove elt s if s is non empty. Uses the unsigned order on KEY.to_int.

iter f set calls f on all elements of set, in the unsigned order of KEY.to_int.

filter f set is the subset of set that only contains the elements that satisfy f. f is called in the unsigned order of KEY.to_int.

for_all f set is true if f is true on all elements of set. Short-circuits on first false. f is called in the unsigned order of KEY.to_int.

fold f set acc returns f elt_n (... (f elt_1 acc) ...), where elt_1, ..., elt_n are the elements of set, in increasing unsigned order of KEY.to_int

split elt set returns s_lt, present, s_gt where s_lt contains all elements of set smaller than elt, s_gt all those greater than elt, and present is true if elt is in set. Uses the unsigned order on KEY.to_int.

Pretty prints the set, pp_sep is called once between each element, it defaults to Format.pp_print_cut

for_all2 ~reflexive ~left_only ~common ~right_only s1 s2 evaluates predicates on the elements of s1 and s2.

• left_only k v1 is called for elements of s1 that don't appear in s2;
• right_only k v2 is called for eleemnts of s2 that don't appear in s1;
• common k v1 v2 is called for shared elements.

All three of these parameters can be either True, False, or a user supplied function (using F). The True and False constructors are faster, as knowing these values in advance avoids having to explore the relevant branches.

for_all2 explores elements in the unsigned order of KEY.to_int. It also has early-return: any false evaluation will stop exploration.

• since v0.15.0

Negation of for_all2. While for_all2 early returns at the first encountered false value. This early returns at the first encountered true.

• since v0.15.0

fold2 ~reflexive ~left_only ~common ~right_only s1 s2 r iterates two sets s1 and s2 simultaneously, updating the accumulator r at each binding:

• left_only x r is called on elements x present in s1 but not s2;
• right_only k v2 r is called on elements present in s2 but not s1
• common k v1 v2 r is called on shared elements.

Each of these can be None instead of a function, in which case the corresponding bindings are ignored. This can dramatically speed up the fold, as it then skips exploration of unneeded subtrees.

fold2 explores bindings in the unsigned order of KEY.to_int.

• since v0.15.0

Calls the argument function on all bindings, just like fold2. Unlike fold2, each function returns unit so no accumulator is threaded.

• since v0.15.0

union a b is the set union of a and b, i.e. the set containing all elements that are either in a or b.

inter a b is the set intersection of a and b, i.e. the set containing all elements that are in both a or b.

disjoint a b is true if a and b have no elements in common.

equal a b is true if a and b contain the same elements.

compare s1 s2 is an order on setss. s1 and s2 are equal if they contain the same bindings (compare by KEY.to_int). s1 is strictly smaller than s2 if the first difference (in the order of KEY.to_int) is an element that appears in s2 but not in s1.

• since v0.11.0

subset a b is true if all elements of a are also in b.

diff s1 s2 is the set of all elements of s1 that aren't in s2.

• since v0.11.0

min_elt_inter s1 s2 is unsigned_min_elt of inter s1 s2, but faster as it does not require computing the whole intersection. Returns None when the intersection is empty.

• since v0.11.0

max_elt_inter s1 s2 is unsigned_max_elt of inter s1 s2, but faster as it does not require computing the whole intersection. Returns None when the intersection is empty.

• since v0.11.0

to_seq st iterates the whole set, in increasing unsigned order of KEY.to_int

to_rev_seq st iterates the whole set, in decreasing unsigned order of KEY.to_int

add_seq s st adds all elements of the sequence s to st in order.

of_seq s creates a new set from the elements of s.

of_list l creates a new set from the elements of l.

to_list s returns the elements of s as a list, in increasing unsigned order of KEY.to_int