package core

  1. Overview
  2. Docs
package core
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Set.TreeSource

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.

Sourceval sexp_of_t : ('elt -> Sexplib0.Sexp.t) -> ('cmp -> Sexplib0.Sexp.t) -> ('elt, 'cmp) t -> Sexplib0.Sexp.t
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, '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) 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
Sourceval 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

Sourceval add : ('a, 'cmp, ('a, 'cmp) t -> 'a -> ('a, 'cmp) t) Base.Set.With_comparator.t
Sourceval remove : ('a, 'cmp, ('a, 'cmp) t -> 'a -> ('a, 'cmp) t) Base.Set.With_comparator.t
Sourceval union : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t) Base.Set.With_comparator.t
Sourceval inter : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t) Base.Set.With_comparator.t
Sourceval diff : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t) Base.Set.With_comparator.t
Sourceval symmetric_diff : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'a) Base.Either.t Base.Sequence.t) Base.Set.With_comparator.t
Sourceval compare_direct : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> int) Base.Set.With_comparator.t
Sourceval equal : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> bool) Base.Set.With_comparator.t
Sourceval is_subset : ('a, 'cmp, ('a, 'cmp) t -> of_:('a, 'cmp) t -> bool) Base.Set.With_comparator.t
Sourceval are_disjoint : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t -> bool) Base.Set.With_comparator.t
Sourceval 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
Sourceval 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
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, ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * 'a option * ('a, 'cmp) t) Base.Set.With_comparator.t
Sourceval split_le_gt : ('a, 'cmp, ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * ('a, 'cmp) t) Base.Set.With_comparator.t
Sourceval 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
Sourceval 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
Sourceval 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
Sourceval 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
Sourceval 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
Sourceval to_map : ('a, 'cmp, ('a, 'cmp) t -> f:('a -> 'b) -> ('a, 'b, 'cmp) Base.Map.t) Base.Set.With_comparator.t
Sourceval quickcheck_observer : 'a Quickcheck.Observer.t -> ('a, 'cmp) t Quickcheck.Observer.t
Sourceval 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
Sourceval 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
Sourceval 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
Sourceval of_sorted_array : ('a, 'cmp, 'a array -> ('a, 'cmp) t Base.Or_error.t) Base.Set.With_comparator.t
Sourceval of_sorted_array_unchecked : ('a, 'cmp, 'a array -> ('a, 'cmp) t) Base.Set.With_comparator.t
Sourceval 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
  • deprecated [since 2023-04] Use [List.stable_dedup] instead.
Sourceval 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
Sourceval filter_map : ('b, 'cmp, ('a, _) t -> f:('a -> 'b option) -> ('b, 'cmp) t) Base.Set.With_comparator.t
Sourceval of_tree : ('a, 'cmp, ('a, 'cmp) t -> ('a, 'cmp) t) Base.Set.With_comparator.t
Sourceval of_hash_set : ('a, 'cmp, 'a Hash_set.t -> ('a, 'cmp) t) Base.Set.With_comparator.t
Sourceval 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.

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

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct