type ('a, 'cmp) tA Tree.t contains just the tree data structure that a set is based on, without
including the comparator. Accordingly, any operation on a Tree.t must also take
as an argument the corresponding comparator.
include sig ... endval sexp_of_t : ('a ‑> Base__.Sexplib.Sexp.t) ‑> ('cmp ‑> Base__.Sexplib.Sexp.t) ‑> ('a, 'cmp) t ‑> Base__.Sexplib.Sexp.tval t_of_sexp_direct : comparator:('elt, 'cmp) Comparator.t ‑> (Sexp.t ‑> 'elt) ‑> Sexp.t ‑> ('elt, 'cmp) tinclude Set_intf.Creators_and_accessors2_with_comparator with type (a, b) set := (a, b) t with type (a, b) t := (a, b) t with type (a, b) tree := (a, b) tinclude Set_intf.Accessors2_with_comparatorinclude Container.S1_phantom_invariantval mem : ('a, _) t ‑> 'a ‑> equal:('a ‑> 'a ‑> bool) ‑> boolChecks whether the provided element is there, using equal.
val length : (_, _) t ‑> intval is_empty : (_, _) t ‑> boolval iter : ('a, _) t ‑> f:('a ‑> unit) ‑> unitval fold : ('a, _) t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> 'accum) ‑> 'accumfold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en
are the elements of t
val fold_result : ('a, _) t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> ('accum, 'e) Result.t) ‑> ('accum, 'e) Result.tfold_result t ~init ~f is a short-circuiting version of fold that runs in the
Result monad. If f returns an Error _, that value is returned without any
additional invocations of f.
val fold_until : ('a, _) t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> ('accum, 'stop) Container_intf.Continue_or_stop.t) ‑> ('accum, 'stop) Container_intf.Finished_or_stopped_early.tfold_until t ~init ~f is a short-circuiting version of fold. If f
returns Stop _ the computation ceases and results in that value. If f returns
Continue _, the fold will proceed.
val exists : ('a, _) t ‑> f:('a ‑> bool) ‑> boolReturns true if and only if there exists an element for which the provided
function evaluates to true. This is a short-circuiting operation.
val for_all : ('a, _) t ‑> f:('a ‑> bool) ‑> boolReturns true if and only if the provided function evaluates to true for all
elements. This is a short-circuiting operation.
val count : ('a, _) t ‑> f:('a ‑> bool) ‑> intReturns the number of elements for which the provided function evaluates to true.
val sum : (module Commutative_group.S with type t = 'sum) ‑> ('a, _) t ‑> f:('a ‑> 'sum) ‑> 'sumReturns the sum of f i for i in the container
val find : ('a, _) t ‑> f:('a ‑> bool) ‑> 'a optionReturns as an option the first element for which f evaluates to true.
val find_map : ('a, _) t ‑> f:('a ‑> 'b option) ‑> 'b optionReturns the first evaluation of f that returns Some, and returns None if there
is no such element.
val to_list : ('a, _) t ‑> 'a listval to_array : ('a, _) t ‑> 'a arrayval min_elt : ('a, _) t ‑> cmp:('a ‑> 'a ‑> int) ‑> 'a optionReturns a min (resp max) element from the collection using the provided cmp
function. In case of a tie, the first element encountered while traversing the
collection is returned. The implementation uses fold so it has the same complexity
as fold. Returns None iff the collection is empty.
val max_elt : ('a, _) t ‑> cmp:('a ‑> 'a ‑> int) ‑> 'a optionval invariants : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> boolval mem : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> 'a ‑> boolval add : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> 'a ‑> ('a, 'cmp) tval remove : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> 'a ‑> ('a, 'cmp) tval union : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> ('a, 'cmp) t ‑> ('a, 'cmp) tval inter : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> ('a, 'cmp) t ‑> ('a, 'cmp) tval diff : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> ('a, 'cmp) t ‑> ('a, 'cmp) tval symmetric_diff : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> ('a, 'cmp) t ‑> ('a, 'a) Either.t Sequence.tval compare_direct : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> ('a, 'cmp) t ‑> intval equal : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> ('a, 'cmp) t ‑> boolval is_subset : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> of_:('a, 'cmp) t ‑> boolval subset : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> ('a, 'cmp) t ‑> boolval fold_until : ('a, _) t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> ('accum, 'stop) Set_intf.Continue_or_stop.t) ‑> ('accum, 'stop) Set_intf.Finished_or_stopped_early.tval fold_right : ('a, _) t ‑> init:'accum ‑> f:('a ‑> 'accum ‑> 'accum) ‑> 'accumval iter2 : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> ('a, 'cmp) t ‑> f:([ `Left of 'a | `Right of 'a | `Both of 'a * 'a ] ‑> unit) ‑> unitval filter : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> f:('a ‑> bool) ‑> ('a, 'cmp) tval partition_tf : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> f:('a ‑> bool) ‑> ('a, 'cmp) t * ('a, 'cmp) tval elements : ('a, _) t ‑> 'a listval min_elt : ('a, _) t ‑> 'a optionval min_elt_exn : ('a, _) t ‑> 'aval max_elt : ('a, _) t ‑> 'a optionval max_elt_exn : ('a, _) t ‑> 'aval choose : ('a, _) t ‑> 'a optionval choose_exn : ('a, _) t ‑> 'aval split : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> 'a ‑> ('a, 'cmp) t * 'a option * ('a, 'cmp) tval group_by : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> equiv:('a ‑> 'a ‑> bool) ‑> ('a, 'cmp) t listval find_exn : ('a, _) t ‑> f:('a ‑> bool) ‑> 'aval find_index : ('a, _) t ‑> int ‑> 'a optionval nth : ('a, _) t ‑> int ‑> 'a optionval remove_index : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t ‑> int ‑> ('a, 'cmp) tval to_sequence : comparator:('a, 'cmp) Comparator.t ‑> ?order:[ `Increasing | `Decreasing ] ‑> ?greater_or_equal_to:'a ‑> ?less_or_equal_to:'a ‑> ('a, 'cmp) t ‑> 'a Sequence.tval merge_to_sequence : comparator:('a, 'cmp) Comparator.t ‑> ?order:[ `Increasing | `Decreasing ] ‑> ?greater_or_equal_to:'a ‑> ?less_or_equal_to:'a ‑> ('a, 'cmp) t ‑> ('a, 'cmp) t ‑> ('a, 'a) Set_intf.Merge_to_sequence_element.t Sequence.tinclude Set_intf.Creators2_with_comparator with type (a, b) t := (a, b) t with type (a, b) tree := (a, b) treeval empty : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) tval singleton : comparator:('a, 'cmp) Comparator.t ‑> 'a ‑> ('a, 'cmp) tval union_list : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) t list ‑> ('a, 'cmp) tval of_list : comparator:('a, 'cmp) Comparator.t ‑> 'a list ‑> ('a, 'cmp) tval of_array : comparator:('a, 'cmp) Comparator.t ‑> 'a array ‑> ('a, 'cmp) tval of_sorted_array : comparator:('a, 'cmp) Comparator.t ‑> 'a array ‑> ('a, 'cmp) t Or_error.tval of_sorted_array_unchecked : comparator:('a, 'cmp) Comparator.t ‑> 'a array ‑> ('a, 'cmp) tval of_increasing_iterator_unchecked : comparator:('a, 'cmp) Comparator.t ‑> len:int ‑> f:(int ‑> 'a) ‑> ('a, 'cmp) tval stable_dedup_list : comparator:('a, 'cmp) Comparator.t ‑> 'a list ‑> 'a listval map : comparator:('b, 'cmp) Comparator.t ‑> ('a, _) set ‑> f:('a ‑> 'b) ‑> ('b, 'cmp) tval filter_map : comparator:('b, 'cmp) Comparator.t ‑> ('a, _) set ‑> f:('a ‑> 'b option) ‑> ('b, 'cmp) tval of_tree : comparator:('a, 'cmp) Comparator.t ‑> ('a, 'cmp) tree ‑> ('a, 'cmp) tval empty_without_value_restriction : (_, _) t