base v0.16.3 · OCaml Package

type ('a, 'cmp) t

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

val sexp_of_t : 
  ('a -> Sexplib0.Sexp.t) ->
  ('cmp -> Sexplib0.Sexp.t) ->
  ('a, 'cmp) t ->
  Sexplib0.Sexp.t

val t_of_sexp_direct : 
  comparator:('elt, 'cmp) Comparator.t ->
  (Sexp.t -> 'elt) ->
  Sexp.t ->
  ('elt, 'cmp) t

include Container.Generic
  with type ('a, 'b) t := ('a, 'b) t
  with type 'a elt := 'a

val length : (_, _) t -> int

val is_empty : (_, _) t -> bool

val iter : ('a, _) t -> f:('a -> unit) -> unit

val fold : ('a, _) t -> init:'acc -> f:('acc -> 'a -> 'acc) -> 'acc

val fold_result : 
  ('a, _) t ->
  init:'acc ->
  f:('acc -> 'a -> ('acc, 'e) Result.t) ->
  ('acc, 'e) Result.t

val exists : ('a, _) t -> f:('a -> bool) -> bool

val for_all : ('a, _) t -> f:('a -> bool) -> bool

val count : ('a, _) t -> f:('a -> bool) -> int

val sum : 
  (module Container.Summable with type t = 'sum) ->
  ('a, _) t ->
  f:('a -> 'sum) ->
  'sum

val find : ('a, _) t -> f:('a -> bool) -> 'a option

val find_map : ('a, _) t -> f:('a -> 'b option) -> 'b option

val to_list : ('a, _) t -> 'a list

val to_array : ('a, _) t -> 'a array

val invariants : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> bool

val mem : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> 'a -> bool

override Container's mem

val add : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  'a ->
  ('a, 'cmp) t

val remove : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  'a ->
  ('a, 'cmp) t

val union : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t

val inter : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t

val diff : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t

val symmetric_diff : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t ->
  ('a, 'a) Either.t Sequence.t

val compare_direct : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t ->
  int

val equal : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t ->
  bool

val is_subset : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  of_:('a, 'cmp) t ->
  bool

val are_disjoint : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t ->
  bool

module Named : sig ... end

val fold_until : 
  ('a, _) t ->
  init:'acc ->
  f:('acc -> 'a -> ('acc, 'final) Container.Continue_or_stop.t) ->
  finish:('acc -> 'final) ->
  'final

val fold_right : ('a, _) t -> init:'acc -> f:('a -> 'acc -> 'acc) -> 'acc

val iter2 : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t ->
  f:([ `Left of 'a | `Right of 'a | `Both of 'a * 'a ] -> unit) ->
  unit

val filter : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t

val partition_tf : 
  ('a, 'cmp) t ->
  f:('a -> bool) ->
  ('a, 'cmp) t * ('a, 'cmp) t

val elements : ('a, _) t -> 'a list

val min_elt : ('a, _) t -> 'a option

val min_elt_exn : ('a, _) t -> 'a

val max_elt : ('a, _) t -> 'a option

val max_elt_exn : ('a, _) t -> 'a

val choose : ('a, _) t -> 'a option

val choose_exn : ('a, _) t -> 'a

val split : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  'a ->
  ('a, 'cmp) t * 'a option * ('a, 'cmp) t

val split_le_gt : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  'a ->
  ('a, 'cmp) t * ('a, 'cmp) t

val split_lt_ge : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  'a ->
  ('a, 'cmp) t * ('a, 'cmp) t

val group_by : ('a, 'cmp) t -> equiv:('a -> 'a -> bool) -> ('a, 'cmp) t list

val find_exn : ('a, _) t -> f:('a -> bool) -> 'a

val nth : ('a, _) t -> int -> 'a option

val remove_index : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  int ->
  ('a, 'cmp) t

val to_tree : ('a, 'cmp) t -> ('a, 'cmp) t

val 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.t

val binary_search : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  compare:('a -> 'key -> int) ->
  Binary_searchable.Which_target_by_key.t ->
  'key ->
  'a option

val binary_search_segmented : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  segment_of:('a -> [ `Left | `Right ]) ->
  Binary_searchable.Which_target_by_segment.t ->
  'a option

val 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) Sequence.Merge_with_duplicates_element.t Sequence.t

val empty : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t

val singleton : comparator:('a, 'cmp) Comparator.t -> 'a -> ('a, 'cmp) t

val union_list : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t list ->
  ('a, 'cmp) t

val of_list : comparator:('a, 'cmp) Comparator.t -> 'a list -> ('a, 'cmp) t

val of_sequence : 
  comparator:('a, 'cmp) Comparator.t ->
  'a Sequence.t ->
  ('a, 'cmp) t

val of_array : comparator:('a, 'cmp) Comparator.t -> 'a array -> ('a, 'cmp) t

val of_sorted_array : 
  comparator:('a, 'cmp) Comparator.t ->
  'a array ->
  ('a, 'cmp) t Or_error.t

val of_sorted_array_unchecked : 
  comparator:('a, 'cmp) Comparator.t ->
  'a array ->
  ('a, 'cmp) t

val of_increasing_iterator_unchecked : 
  comparator:('a, 'cmp) Comparator.t ->
  len:int ->
  f:(int -> 'a) ->
  ('a, 'cmp) t

val stable_dedup_list : comparator:('a, _) Comparator.t -> 'a list -> 'a list

val map : 
  comparator:('b, 'cmp) Comparator.t ->
  ('a, _) t ->
  f:('a -> 'b) ->
  ('b, 'cmp) t

The types of map and filter_map are subtle. The input set, ('a, _) set, reflects the fact that these functions take a set of *any* type, with any comparator, while the output set, ('b, 'cmp) t, reflects that the output set has the particular 'cmp of the creation function. The comparator can come in one of three ways, depending on which set module is used

Set.map -- comparator comes as an argument
Set.Poly.map -- comparator is polymorphic comparison
Foo.Set.map -- comparator is Foo.comparator

val filter_map : 
  comparator:('b, 'cmp) Comparator.t ->
  ('a, _) t ->
  f:('a -> 'b option) ->
  ('b, 'cmp) t

val of_tree : 
  comparator:('a, 'cmp) Comparator.t ->
  ('a, 'cmp) t ->
  ('a, 'cmp) t

val empty_without_value_restriction : (_, _) t

package base