Module Set.Make

Parameters

module Ord : Stdlib.Set.OrderedType

Signature

module S : sig ... end
include module type of struct include S end
type elt = Ord.t
type t = Stdlib__Set.Make(Ord).t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val disjoint : t -> t -> bool
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val map : (elt -> elt) -> t -> t
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val filter_map : (elt -> elt option) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val min_elt_opt : t -> elt option
val max_elt : t -> elt
val max_elt_opt : t -> elt option
val choose : t -> elt
val choose_opt : t -> elt option
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val find_opt : elt -> t -> elt option
val find_first : (elt -> bool) -> t -> elt
val find_first_opt : (elt -> bool) -> t -> elt option
val find_last : (elt -> bool) -> t -> elt
val find_last_opt : (elt -> bool) -> t -> elt option
val of_list : elt list -> t
val to_seq_from : elt -> t -> elt Stdlib.Seq.t
val to_seq : t -> elt Stdlib.Seq.t
val to_rev_seq : t -> elt Stdlib.Seq.t
val add_seq : elt Stdlib.Seq.t -> t -> t
val of_seq : elt Stdlib.Seq.t -> t
val cmp : Ord.t -> Ord.t -> int

cmp is Ord.compare and is the comparison function that implements this set.

val size : t -> int

(size t) is cardinal.

val to_list : t -> elt list

(to_list) is elements.

val replace : elt -> t -> t

(replace elt t) is (remove elt t |> add elt).

module S = Set.Make (struct type t = int * string let compare = on compare fst end)
S.(empty |> add (1,"one") |> add     (1,"ONE") |> to_list) = [(1, "one")]
S.(empty |> add (1,"one") |> replace (1,"ONE") |> to_list) = [(1, "ONE")]
val addwith : ('a -> elt) -> 'a -> t -> t

(addwith f) is (fun f x t -> add (f x) t).

val addwhen : (elt -> bool) -> elt -> t -> t

(addwhen p x xs) is (add x xs) when p x = true and otherwise is xs.

Development Utils

val random : ?size:(unit -> int) -> (unit -> elt) -> unit -> t

(random ?size r ()) is a random set of size (size ()) (default: < 100), and each element is given by (r ()).

val to_string : ?sep:string -> (elt -> string) -> t -> string

(to_string ?(sep=", ") f t) returns a string representation of the set t, where the string representation of each elt is given by f.

val print : ?sep:string -> (elt -> string) -> t -> unit

(print ?sep f t) is (to_string ?sep f t |> print_endline).