Up

Module Poly

Signature

type ('a, 'b) set
module Tree : sig .. end
val t_of_sexp : (Sexplib.Sexp.t -> 'elt) -> Sexplib.Sexp.t -> 'elt t
val sexp_of_t : ('elt -> Sexplib.Sexp.t) -> 'elt t -> Sexplib.Sexp.t
val compare : ('elt -> 'elt -> int) -> 'elt t -> 'elt t -> int
val bin_t : 'elt Bin_prot.Type_class.t -> 'elt t Bin_prot.Type_class.t
val bin_read_t : 'elt Bin_prot.Read.reader -> 'elt t Bin_prot.Read.reader
val __bin_read_t__ : 'elt Bin_prot.Read.reader -> (int -> 'elt t) Bin_prot.Read.reader
val bin_reader_t : 'elt Bin_prot.Type_class.reader -> 'elt t Bin_prot.Type_class.reader
val bin_size_t : 'elt Bin_prot.Size.sizer -> 'elt t Bin_prot.Size.sizer
val bin_write_t : 'elt Bin_prot.Write.writer -> 'elt t Bin_prot.Write.writer
val bin_writer_t : 'elt Bin_prot.Type_class.writer -> 'elt t Bin_prot.Type_class.writer
include Core_kernel.Core_set_intf.Creators_and_accessors1 with type ('a, 'b) set := ('a, 'b) set with type 'elt t := 'elt t with type 'elt tree := 'elt Tree.t with type comparator_witness := Core_kernel.Comparator.Poly.comparator_witness
include Core_set_intf.Accessors1
include Container.S1
type 'a t
val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool

Checks whether the provided element is there, using polymorphic compare if equal is not provided

val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val 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

val 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.

val 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.

val count : 'a t -> f:('a -> bool) -> int

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

val sum : (module Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum

Returns the sum of f i for i in the container

val find : 'a t -> f:('a -> bool) -> 'a option

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

val 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.

val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option

Returns a minimum (resp maximum) element from the collection using the provided cmp function, or None if the collection is empty. In case of a tie, the first element encountered while traversing the collection is returned. The implementation uses fold so it has the same complexity as fold.

val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
type 'a tree
type comparator_witness
val invariants : _ t -> bool
val mem : 'a t -> 'a -> bool
val add : 'a t -> 'a -> 'a t
val remove : 'a t -> 'a -> 'a t
val union : 'a t -> 'a t -> 'a t
val inter : 'a t -> 'a t -> 'a t
val diff : 'a t -> 'a t -> 'a t
val symmetric_diff : 'a t -> 'a t -> ('a, 'a) Either.t Sequence.t
val compare_direct : 'a t -> 'a t -> int
val equal : 'a t -> 'a t -> bool
val subset : 'a t -> 'a t -> bool
val fold_until : 'a t -> init:'b -> f:('b -> 'a -> [
| `Continue of 'b
| `Stop of 'b
]) -> 'b
val fold_right : 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b
val iter2 : 'a t -> 'a t -> f:([
| `Left of 'a
| `Right of 'a
| `Both of 'a * 'a
] -> unit) -> unit
val filter : 'a t -> f:('a -> bool) -> 'a t
val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t
val elements : 'a t -> 'a list
val min_elt : 'a t -> 'a option
val min_elt_exn : 'a t -> 'a
val max_elt : 'a t -> 'a option
val max_elt_exn : 'a t -> 'a
val choose : 'a t -> 'a option
val choose_exn : 'a t -> 'a
val split : 'a t -> 'a -> 'a t * 'a option * 'a t
val group_by : 'a t -> equiv:('a -> 'a -> bool) -> 'a t list
val find_exn : 'a t -> f:('a -> bool) -> 'a
val find_index : 'a t -> int -> 'a option
val remove_index : 'a t -> int -> 'a t
val to_tree : 'a t -> 'a tree
val to_sequence : ?order:[
| `Increasing
| `Decreasing
] -> ?greater_or_equal_to:'a -> ?less_or_equal_to:'a -> 'a t -> 'a Sequence.t
val to_map : 'a t -> f:('a -> 'b) -> ('a, 'b, comparator_witness) Core_set_intf.Map.t
val obs : 'a Quickcheck.obs -> 'a t Quickcheck.obs
val shrinker : 'a Quickcheck.shr -> 'a t Quickcheck.shr
include Core_set_intf.Creators1 with type 'a t := 'a t with type 'a tree := 'a tree with type comparator_witness := comparator_witness
type ('a, 'cmp) set
type 'a t
type 'a tree
type comparator_witness
val empty : 'a t
val singleton : 'a -> 'a t
val union_list : 'a t list -> 'a t
val of_list : 'a list -> 'a t
val of_array : 'a array -> 'a t
val of_sorted_array : 'a array -> 'a t Or_error.t
val of_sorted_array_unchecked : 'a array -> 'a t
val stable_dedup_list : 'a list -> 'a list
val map : ('a, _) set -> f:('a -> 'b) -> 'b t
val filter_map : ('a, _) set -> f:('a -> 'b option) -> 'b t
val of_tree : 'a tree -> 'a t
val of_map_keys : ('a, _, comparator_witness) Core_set_intf.Map.t -> 'a t