Module Bignum.Set

module Elt : sig ... end with type t = t and type comparator_witness = comparator_witness
module Tree : sig ... end
include Core_kernel.Set_intf.S_plain with module Elt := Elt and module Tree := Tree
module Elt : sig ... end
include sig ... end
val compare : t ‑> t ‑> Core_kernel__.Import.int
val sexp_of_t : t ‑> Base.Sexp.t
include Core_kernel.Set_intf.Creators_and_accessors0 with type (a, b) set := (a, b) Base.Set.t with type t := t with type tree := Tree.t with type elt := Elt.t with type named := named with type comparator_witness := Elt.comparator_witness
include Core_kernel.Set_intf.Accessors0
include Core_kernel.Set_intf.Set.Accessors0
type t
type elt
val length : t ‑> int
val is_empty : t ‑> bool
val iter : t ‑> f:(elt ‑> unit) ‑> unit
val fold : t ‑> init:'accum ‑> f:('accum ‑> elt ‑> 'accum) ‑> 'accum
val fold_result : t ‑> init:'accum ‑> f:('accum ‑> elt ‑> ('accum, 'e) Base.Result.t) ‑> ('accum, 'e) Base.Result.t
val exists : t ‑> f:(elt ‑> bool) ‑> bool
val for_all : t ‑> f:(elt ‑> bool) ‑> bool
val count : t ‑> f:(elt ‑> bool) ‑> int
val sum : (module Base.Commutative_group.S with type t = 'sum) ‑> t ‑> f:(elt ‑> 'sum) ‑> 'sum
val find : t ‑> f:(elt ‑> bool) ‑> elt option
val find_map : t ‑> f:(elt ‑> 'a option) ‑> 'a option
val to_list : t ‑> elt list
val to_array : t ‑> elt array
type tree
type comparator_witness
val invariants : t ‑> bool
val mem : t ‑> elt ‑> bool
val add : t ‑> elt ‑> t
val remove : t ‑> elt ‑> t
val union : t ‑> t ‑> t
val inter : t ‑> t ‑> t
val diff : t ‑> t ‑> t
val symmetric_diff : t ‑> t ‑> (elt, elt) Base.Either.t Base.Sequence.t
val compare_direct : t ‑> t ‑> int
val equal : t ‑> t ‑> bool
val is_subset : t ‑> of_:t ‑> bool
val subset : t ‑> t ‑> bool
  • Deprecated [since 2016-09] Replace [Set.subset t1 t2] with [Set.is_subset t1 ~of_:t2]
type named
module Named : sig ... end
val fold_until : t ‑> init:'b ‑> f:('b ‑> elt ‑> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ‑> finish:('b ‑> 'final) ‑> 'final
val fold_right : t ‑> init:'b ‑> f:(elt ‑> 'b ‑> 'b) ‑> 'b
val iter2 : t ‑> t ‑> f:([ `Both of elt * elt | `Left of elt | `Right of elt ] ‑> unit) ‑> unit
val filter : t ‑> f:(elt ‑> bool) ‑> t
val partition_tf : t ‑> f:(elt ‑> bool) ‑> t * t
val elements : t ‑> elt list
val min_elt : t ‑> elt option
val min_elt_exn : t ‑> elt
val max_elt : t ‑> elt option
val max_elt_exn : t ‑> elt
val choose : t ‑> elt option
val choose_exn : t ‑> elt
val split : t ‑> elt ‑> t * elt option * t
val group_by : t ‑> equiv:(elt ‑> elt ‑> bool) ‑> t list
val find_exn : t ‑> f:(elt ‑> bool) ‑> elt
val find_index : t ‑> int ‑> elt option
  • Deprecated [since 2016-10] Use [nth]
val nth : t ‑> int ‑> elt option
val remove_index : t ‑> int ‑> t
val to_tree : t ‑> tree
val to_sequence : ?⁠order:[ `Decreasing | `Increasing ] ‑> ?⁠greater_or_equal_to:elt ‑> ?⁠less_or_equal_to:elt ‑> t ‑> elt Base.Sequence.t
val merge_to_sequence : ?⁠order:[ `Decreasing | `Increasing ] ‑> ?⁠greater_or_equal_to:elt ‑> ?⁠less_or_equal_to:elt ‑> t ‑> t ‑> (elt, elt) Base__.Set_intf.Merge_to_sequence_element.t Base.Sequence.t
val to_map : t ‑> f:(elt ‑> 'data) ‑> (elt, 'data, comparator_witness) Core_kernel.Map.t
include Core_kernel.Set_intf.Creators0 with type t := t with type tree := tree with type elt := elt with type comparator_witness := comparator_witness
include Core_kernel.Set_intf.Set.Creators0
type ('a, 'cmp) set
type t
type tree
type elt
type comparator_witness
val empty : t
val singleton : elt ‑> t
val union_list : t list ‑> t
val of_list : elt list ‑> t
val of_array : elt array ‑> t
val of_sorted_array : elt array ‑> t Base.Or_error.t
val of_sorted_array_unchecked : elt array ‑> t
val of_increasing_iterator_unchecked : len:int ‑> f:(int ‑> elt) ‑> t
val stable_dedup_list : elt list ‑> elt list
val map : ('a, 'b) set ‑> f:('a ‑> elt) ‑> t
val filter_map : ('a, 'b) set ‑> f:('a ‑> elt option) ‑> t
val of_tree : tree ‑> t
val of_hash_set : elt Core_kernel.Hash_set.t ‑> t
val of_hashtbl_keys : (elt, _) Core_kernel.Hashtbl.t ‑> t
val of_map_keys : (elt, _, comparator_witness) Core_kernel.Map.t ‑> t
module Provide_of_sexp : functor (Elt : sig ... end with type t := Elt.t) -> sig ... end with type t := t
module Provide_bin_io : functor (Elt : sig ... end with type t := Elt.t) -> Core_kernel.Set_intf.Binable.S with type t := t
module Provide_hash : functor (Elt : Core_kernel__.Import.Hasher.S with type t := Elt.t) -> sig ... end with type t := t
include Core_kernel.Sexpable.S with type t := t
type t
val t_of_sexp : Base.Sexp.t ‑> t
val sexp_of_t : t ‑> Base.Sexp.t