Module `Set.Using_comparator`Source

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) Base.Set.t

Source

val sexp_of_t : 
  ('elt -> Sexplib0.Sexp.t) ->
  ('cmp -> Sexplib0.Sexp.t) ->
  ('elt, 'cmp) Base.Set.Using_comparator.t ->
  Sexplib0.Sexp.t

Source

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

Sourcemodule Tree : sig ... end

include Base.Container.Generic
  with type ('a, 'cmp, _) t := ('a, 'cmp) Base.Set.Using_comparator.t
  with type 'a elt := 'a

Sourceval length : (_, _) Base.Set.Using_comparator.t -> int

Sourceval is_empty : (_, _) Base.Set.Using_comparator.t -> bool

Sourceval iter : ('a, _) Base.Set.Using_comparator.t -> f:('a -> unit) -> unit

Source

val fold : 
  ('a, _) Base.Set.Using_comparator.t ->
  init:'acc ->
  f:('acc -> 'a -> 'acc) ->
  'acc

Source

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

Sourceval exists : ('a, _) Base.Set.Using_comparator.t -> f:('a -> bool) -> bool

Sourceval for_all : ('a, _) Base.Set.Using_comparator.t -> f:('a -> bool) -> bool

Sourceval count : ('a, _) Base.Set.Using_comparator.t -> f:('a -> bool) -> int

Source

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

Sourceval find : ('a, _) Base.Set.Using_comparator.t -> f:('a -> bool) -> 'a option

Source

val find_map : 
  ('a, _) Base.Set.Using_comparator.t ->
  f:('a -> 'b option) ->
  'b option

Sourceval to_list : ('a, _) Base.Set.Using_comparator.t -> 'a list

Sourceval to_array : ('a, _) Base.Set.Using_comparator.t -> 'a array

Sourceval invariants : ('a, 'cmp) Base.Set.Using_comparator.t -> bool

Sourceval mem : ('a, 'cmp) Base.Set.Using_comparator.t -> 'a -> bool

override Container's mem

Source

val add : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  'a ->
  ('a, 'cmp) Base.Set.Using_comparator.t

Source

val remove : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  'a ->
  ('a, 'cmp) Base.Set.Using_comparator.t

Source

val union : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t

Source

val inter : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t

Source

val diff : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t

Source

val symmetric_diff : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'a) Base.Either.t Base.Sequence.t

Source

val compare_direct : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  int

Source

val equal : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  bool

Source

val is_subset : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  of_:('a, 'cmp) Base.Set.Using_comparator.t ->
  bool

Source

val are_disjoint : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  bool

Sourcemodule Named : sig ... end

Source

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

Source

val fold_right : 
  ('a, _) Base.Set.Using_comparator.t ->
  init:'acc ->
  f:('a -> 'acc -> 'acc) ->
  'acc

Source

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

Source

val filter : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  f:('a -> bool) ->
  ('a, 'cmp) Base.Set.Using_comparator.t

Source

val partition_tf : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  f:('a -> bool) ->
  ('a, 'cmp) Base.Set.Using_comparator.t
  * ('a, 'cmp) Base.Set.Using_comparator.t

Sourceval elements : ('a, _) Base.Set.Using_comparator.t -> 'a list

Sourceval min_elt : ('a, _) Base.Set.Using_comparator.t -> 'a option

Sourceval min_elt_exn : ('a, _) Base.Set.Using_comparator.t -> 'a

Sourceval max_elt : ('a, _) Base.Set.Using_comparator.t -> 'a option

Sourceval max_elt_exn : ('a, _) Base.Set.Using_comparator.t -> 'a

Sourceval choose : ('a, _) Base.Set.Using_comparator.t -> 'a option

Sourceval choose_exn : ('a, _) Base.Set.Using_comparator.t -> 'a

Source

val split : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  'a ->
  ('a, 'cmp) Base.Set.Using_comparator.t
  * 'a option
  * ('a, 'cmp) Base.Set.Using_comparator.t

Source

val split_le_gt : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  'a ->
  ('a, 'cmp) Base.Set.Using_comparator.t
  * ('a, 'cmp) Base.Set.Using_comparator.t

Source

val split_lt_ge : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  'a ->
  ('a, 'cmp) Base.Set.Using_comparator.t
  * ('a, 'cmp) Base.Set.Using_comparator.t

Source

val group_by : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  equiv:('a -> 'a -> bool) ->
  ('a, 'cmp) Base.Set.Using_comparator.t list

Sourceval find_exn : ('a, _) Base.Set.Using_comparator.t -> f:('a -> bool) -> 'a

Sourceval nth : ('a, _) Base.Set.Using_comparator.t -> int -> 'a option

Source

val remove_index : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  int ->
  ('a, 'cmp) Base.Set.Using_comparator.t

Source

val to_tree : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.Tree.t

Source

val to_sequence : 
  ?order:[ `Increasing | `Decreasing ] ->
  ?greater_or_equal_to:'a ->
  ?less_or_equal_to:'a ->
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  'a Base.Sequence.t

Source

val binary_search : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  compare:('a -> 'key -> int) ->
  Base.Binary_searchable.Which_target_by_key.t ->
  'key ->
  'a option

Source

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

Source

val merge_to_sequence : 
  ?order:[ `Increasing | `Decreasing ] ->
  ?greater_or_equal_to:'a ->
  ?less_or_equal_to:'a ->
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'a) Base.Sequence.Merge_with_duplicates_element.t Base.Sequence.t

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

deprecated [since 2023-04] Use [List.stable_dedup] instead.

Source

val map : 
  comparator:('b, 'cmp) Base.Comparator.t ->
  ('a, _) Base.Set.Using_comparator.t ->
  f:('a -> 'b) ->
  ('b, 'cmp) Base.Set.Using_comparator.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

Source

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

Source

val of_tree : 
  comparator:('a, 'cmp) Base.Comparator.t ->
  ('a, 'cmp) Base.Set.Using_comparator.Tree.t ->
  ('a, 'cmp) Base.Set.Using_comparator.t

Source

val comparator_s : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Comparator.Module.t

Source

val comparator : 
  ('a, 'cmp) Base.Set.Using_comparator.t ->
  ('a, 'cmp) Base.Comparator.t

Source

val hash_fold_direct : 
  'elt Base.Hash.folder ->
  ('elt, 'cmp) Base.Set.Using_comparator.t Base.Hash.folder

Sourcemodule Empty_without_value_restriction (Elt : Base.Comparator.S1) : sig ... end

Module Set.Using_comparatorSource

Module `Set.Using_comparator`Source