package core

You can search for identifiers within the package.

in-package search v0.2.0

Module `Set.Tree`Source

Sourcetype ('elt, 'cmp) t = ('elt, 'cmp) Base.Set.Using_comparator.Tree.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.

Source

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

Sourcemodule Named = Base.Set.Using_comparator.Tree.Named

include Set_intf.Creators_and_accessors_generic
  with type ('a, 'b) set := ('a, 'b) t
  with type ('a, 'b) t := ('a, 'b) t
  with type ('a, 'b) tree := ('a, 'b) t
  with type ('a, 'b, 'c) create_options :=
         ('a, 'b, 'c) Base.Set.With_comparator.t
  with type ('a, 'b, 'c) access_options :=
         ('a, 'b, 'c) Base.Set.With_comparator.t
  with type 'a elt := 'a
  with type 'c cmp := 'c
  with module Named := Named

include Set_intf.Accessors_generic
  with type ('a, 'b) t := ('a, 'b) t
  with type ('a, 'b) tree := ('a, 'b) t
  with type 'a elt := 'a
  with type 'cmp cmp := 'cmp
  with type ('a, 'b, 'c) access_options :=
         ('a, 'b, 'c) Base.Set.With_comparator.t
  with module Named := Named

include Base.Set.Accessors_generic
  with type ('a, 'b) t := ('a, 'b) t
  with type ('a, 'b) tree := ('a, 'b) t
  with type 'a elt := 'a
  with type 'cmp cmp := 'cmp
  with type ('a, 'b, 'c) access_options :=
         ('a, 'b, 'c) Base.Set.With_comparator.t
  with module Named := Named

include Base.Container.Generic
  with type ('a, 'b) t := ('a, 'b) 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

Source

val fold_result : 
  ('a, _) t ->
  init:'acc ->
  f:('acc -> 'a -> ('acc, 'e) Base.Result.t) ->
  ('acc, 'e) Base.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

Source

val sum : 
  (module Base.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, ('a, 'cmp) t -> bool) Base.Set.With_comparator.t

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

override Container's mem

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

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

Source

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

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

Source

val 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

Source

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

Source

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

Source

val split_lt_ge : 
  ('a, 'cmp, ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * ('a, 'cmp) t)
    Base.Set.With_comparator.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

Source

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

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

Source

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

Source

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

Source

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

Source

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

Source

val to_map : 
  ('a, 'cmp, ('a, 'cmp) t -> f:('a -> 'b) -> ('a, 'b, 'cmp) Base.Map.t)
    Base.Set.With_comparator.t

Source

val quickcheck_observer : 
  'a Quickcheck.Observer.t ->
  ('a, 'cmp) t Quickcheck.Observer.t

Source

val quickcheck_shrinker : 
  ('a, 'cmp, 'a Quickcheck.Shrinker.t -> ('a, 'cmp) t Quickcheck.Shrinker.t)
    Base.Set.With_comparator.t

include Set_intf.Creators_generic
  with type ('a, 'b) t := ('a, 'b) t
  with type ('a, 'b) tree := ('a, 'b) t
  with type 'a elt := 'a
  with type 'cmp cmp := 'cmp
  with type ('a, 'b) set := ('a, 'b) t
  with type ('a, 'b, 'c) create_options :=
         ('a, 'b, 'c) Base.Set.With_comparator.t

include Base.Set.Creators_generic
  with type ('a, 'b) t := ('a, 'b) t
  with type ('a, 'b) tree := ('a, 'b) t
  with type 'a elt := 'a
  with type 'cmp cmp := 'cmp
  with type ('a, 'b) set := ('a, 'b) t
  with type ('a, 'b, 'c) create_options :=
         ('a, 'b, 'c) Base.Set.With_comparator.t

Sourceval empty : ('a, 'cmp, ('a, 'cmp) t) Base.Set.With_comparator.t

Sourceval singleton : ('a, 'cmp, 'a -> ('a, 'cmp) t) Base.Set.With_comparator.t

Source

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

Sourceval of_list : ('a, 'cmp, 'a list -> ('a, 'cmp) t) Base.Set.With_comparator.t

Source

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

Sourceval of_array : ('a, 'cmp, 'a array -> ('a, 'cmp) t) Base.Set.With_comparator.t

Source

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

Source

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

Source

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

Sourceval stable_dedup_list : ('a, _, 'a list -> 'a list) Base.Set.With_comparator.t

Source

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

Source

val of_tree : 
  ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t) Base.Set.With_comparator.t

Source

val of_hash_set : 
  ('a, 'cmp, 'a Hash_set.t -> ('a, 'cmp) t) Base.Set.With_comparator.t

Source

val of_hashtbl_keys : 
  ('a, 'cmp, ('a, _) Hashtbl.t -> ('a, 'cmp) t) Base.Set.With_comparator.t

Sourceval of_map_keys : ('a, _, 'cmp) Base.Map.t -> ('a, 'cmp) t

Never requires a comparator because it can get one from the input Map.t.

Source

val quickcheck_generator : 
  ('a, 'cmp, 'a Quickcheck.Generator.t -> ('a, 'cmp) t Quickcheck.Generator.t)
    Base.Set.With_comparator.t

package core

Module Set.TreeSource

Module `Set.Tree`Source