package base

  1. Overview
  2. Docs

Module Set.Using_comparatorSource

Using comparator is a similar interface as the toplevel of Set, except the functions take a ~comparator:('elt, 'cmp) Comparator.t where the functions at the toplevel of Set takes a ('elt, 'cmp) comparator.

Sourcetype nonrec ('elt, 'cmp) t = ('elt, 'cmp) t
Sourceval sexp_of_t : ('elt -> Sexplib0.Sexp.t) -> ('cmp -> Sexplib0.Sexp.t) -> ('elt, 'cmp) t -> Sexplib0.Sexp.t
Sourceval t_of_sexp_direct : comparator:('elt, 'cmp) Comparator.t -> (Sexp.t -> 'elt) -> Sexp.t -> ('elt, 'cmp) t
Sourcemodule Tree : sig ... end
include Container.Generic with type ('a, 'cmp, _) t := ('a, 'cmp) t with type 'a elt := 'a
Sourceval length : (_, _) t -> int
Sourceval is_empty : (_, _) t -> bool
Sourceval iter : ('a, _) t -> f:('a -> unit) -> unit
Sourceval fold : ('a, _) t -> init:'acc -> f:('acc -> 'a -> 'acc) -> 'acc
Sourceval fold_result : ('a, _) t -> init:'acc -> f:('acc -> 'a -> ('acc, 'e) Result.t) -> ('acc, 'e) Result.t
Sourceval exists : ('a, _) t -> f:('a -> bool) -> bool
Sourceval for_all : ('a, _) t -> f:('a -> bool) -> bool
Sourceval count : ('a, _) t -> f:('a -> bool) -> int
Sourceval sum : (module Container.Summable with type t = 'sum) -> ('a, _) t -> f:('a -> 'sum) -> 'sum
Sourceval find : ('a, _) t -> f:('a -> bool) -> 'a option
Sourceval find_map : ('a, _) t -> f:('a -> 'b option) -> 'b option
Sourceval to_list : ('a, _) t -> 'a list
Sourceval to_array : ('a, _) t -> 'a array
Sourceval invariants : ('a, 'cmp) t -> bool
Sourceval mem : ('a, 'cmp) t -> 'a -> bool

override Container's mem

Sourceval add : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t
Sourceval remove : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t
Sourceval union : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
Sourceval inter : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
Sourceval diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
Sourceval symmetric_diff : ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'a) Either.t Sequence.t
Sourceval compare_direct : ('a, 'cmp) t -> ('a, 'cmp) t -> int
Sourceval equal : ('a, 'cmp) t -> ('a, 'cmp) t -> bool
Sourceval is_subset : ('a, 'cmp) t -> of_:('a, 'cmp) t -> bool
Sourceval are_disjoint : ('a, 'cmp) t -> ('a, 'cmp) t -> bool
Sourcemodule Named : sig ... end
Sourceval fold_until : ('a, _) t -> init:'acc -> f:('acc -> 'a -> ('acc, 'final) Container.Continue_or_stop.t) -> finish:('acc -> 'final) -> 'final
Sourceval fold_right : ('a, _) t -> init:'acc -> f:('a -> 'acc -> 'acc) -> 'acc
Sourceval iter2 : ('a, 'cmp) t -> ('a, 'cmp) t -> f:([ `Left of 'a | `Right of 'a | `Both of 'a * 'a ] -> unit) -> unit
Sourceval filter : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t
Sourceval partition_tf : ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t * ('a, 'cmp) t
Sourceval elements : ('a, _) t -> 'a list
Sourceval min_elt : ('a, _) t -> 'a option
Sourceval min_elt_exn : ('a, _) t -> 'a
Sourceval max_elt : ('a, _) t -> 'a option
Sourceval max_elt_exn : ('a, _) t -> 'a
Sourceval choose : ('a, _) t -> 'a option
Sourceval choose_exn : ('a, _) t -> 'a
Sourceval split : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * 'a option * ('a, 'cmp) t
Sourceval split_le_gt : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * ('a, 'cmp) t
Sourceval split_lt_ge : ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * ('a, 'cmp) t
Sourceval group_by : ('a, 'cmp) t -> equiv:('a -> 'a -> bool) -> ('a, 'cmp) t list
Sourceval find_exn : ('a, _) t -> f:('a -> bool) -> 'a
Sourceval nth : ('a, _) t -> int -> 'a option
Sourceval remove_index : ('a, 'cmp) t -> int -> ('a, 'cmp) t
Sourceval to_tree : ('a, 'cmp) t -> ('a, 'cmp) Tree.t
Sourceval to_sequence : ?order:[ `Increasing | `Decreasing ] -> ?greater_or_equal_to:'a -> ?less_or_equal_to:'a -> ('a, 'cmp) t -> 'a Sequence.t
Sourceval binary_search_segmented : ('a, 'cmp) t -> segment_of:('a -> [ `Left | `Right ]) -> Binary_searchable.Which_target_by_segment.t -> 'a option
Sourceval merge_to_sequence : ?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
Sourceval empty : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t
Sourceval singleton : comparator:('a, 'cmp) Comparator.t -> 'a -> ('a, 'cmp) t
Sourceval union_list : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t list -> ('a, 'cmp) t
Sourceval of_list : comparator:('a, 'cmp) Comparator.t -> 'a list -> ('a, 'cmp) t
Sourceval of_sequence : comparator:('a, 'cmp) Comparator.t -> 'a Sequence.t -> ('a, 'cmp) t
Sourceval of_array : comparator:('a, 'cmp) Comparator.t -> 'a array -> ('a, 'cmp) t
Sourceval of_sorted_array : comparator:('a, 'cmp) Comparator.t -> 'a array -> ('a, 'cmp) t Or_error.t
Sourceval of_sorted_array_unchecked : comparator:('a, 'cmp) Comparator.t -> 'a array -> ('a, 'cmp) t
Sourceval of_increasing_iterator_unchecked : comparator:('a, 'cmp) Comparator.t -> len:int -> f:(int -> 'a) -> ('a, 'cmp) t
Sourceval stable_dedup_list : comparator:('a, _) Comparator.t -> 'a list -> 'a list
  • deprecated [since 2023-04] Use [List.stable_dedup] instead.
Sourceval 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
Sourceval filter_map : comparator:('b, 'cmp) Comparator.t -> ('a, _) t -> f:('a -> 'b option) -> ('b, 'cmp) t
Sourceval of_tree : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) Tree.t -> ('a, 'cmp) t
Sourceval comparator_s : ('a, 'cmp) t -> ('a, 'cmp) Comparator.Module.t
Sourceval comparator : ('a, 'cmp) t -> ('a, 'cmp) Comparator.t
Sourceval hash_fold_direct : 'elt Hash.folder -> ('elt, 'cmp) t Hash.folder