package base

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

Module Using_comparator.TreeSource

Sourcetype ('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.

Sourceval sexp_of_t : ('a -> Sexplib0.Sexp.t) -> ('cmp -> Sexplib0.Sexp.t) -> ('a, 'cmp) t -> Sexplib0.Sexp.t
Sourceval t_of_sexp_direct : comparator:('elt, 'cmp) Comparator.t -> (Sexp.t -> 'elt) -> Sexp.t -> ('elt, 'cmp) t
Sourcemodule Named : sig ... end
include Container.S1_phantom_invariant with type ('a, 'b) t := ('a, 'b) t
Sourceval length : (_, _) t -> int
Sourceval is_empty : (_, _) t -> bool
Sourceval iter : ('a, _) t -> f:('a -> unit) -> unit
Sourceval fold : ('a, _) t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum

fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en are the elements of t.

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

fold_result t ~init ~f is a short-circuiting version of fold that runs in the Result monad. If f returns an Error _, that value is returned without any additional invocations of f.

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

Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.

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

Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.

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

Returns the number of elements for which the provided function evaluates to true.

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

Returns the sum of f i for all i in the container.

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

Returns as an option the first element for which f evaluates to true.

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

Returns the first evaluation of f that returns Some, and returns None if there is no such element.

Sourceval to_list : ('a, _) t -> 'a list
Sourceval to_array : ('a, _) t -> 'a array
Sourceval invariants : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> bool
Sourceval mem : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> 'a -> bool
Sourceval add : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> 'a -> ('a, 'cmp) t
Sourceval remove : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> 'a -> ('a, 'cmp) t
Sourceval union : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
Sourceval inter : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
Sourceval diff : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'cmp) t
Sourceval symmetric_diff : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> ('a, 'cmp) t -> ('a, 'a) Either.t Sequence.t
Sourceval compare_direct : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> ('a, 'cmp) t -> int
Sourceval equal : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> ('a, 'cmp) t -> bool
Sourceval is_subset : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> of_:('a, 'cmp) t -> bool
Sourceval are_disjoint : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> ('a, 'cmp) t -> bool
Sourceval fold_until : ('a, _) t -> init:'accum -> f:('accum -> 'a -> ('accum, 'final) Container.Continue_or_stop.t) -> finish:('accum -> 'final) -> 'final
Sourceval fold_right : ('a, _) t -> init:'accum -> f:('a -> 'accum -> 'accum) -> 'accum
Sourceval 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
Sourceval filter : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> f:('a -> bool) -> ('a, 'cmp) t
Sourceval partition_tf : comparator:('a, 'cmp) Comparator.t -> ('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 : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> 'a -> ('a, 'cmp) t * 'a option * ('a, 'cmp) t
Sourceval group_by : comparator:('a, 'cmp) Comparator.t -> ('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 : comparator:('a, 'cmp) Comparator.t -> ('a, 'cmp) t -> int -> ('a, 'cmp) t
Sourceval to_tree : ('a, 'cmp) t -> ('a, 'cmp) t
Sourceval 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
Sourceval 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
Sourceval 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
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, 'cmp) Comparator.t -> 'a list -> 'a list
Sourceval map : comparator:('b, 'cmp) Comparator.t -> ('a, _) t -> f:('a -> 'b) -> ('b, 'cmp) t
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) t -> ('a, 'cmp) t
Sourceval empty_without_value_restriction : (_, _) 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