Set (melange.Melange_compiler_libs.Shape.Uid.Set)

type elt = T.t;

type t = Stdlib.Set.Make(T).t;

let empty: t;

let add: elt => t => t;

let singleton: elt => t;

let remove: elt => t => t;

let union: t => t => t;

let inter: t => t => t;

let disjoint: t => t => bool;

let diff: t => t => t;

let cardinal: t => int;

let elements: t => list(elt);

let min_elt: t => elt;

let min_elt_opt: t => option(elt);

let max_elt: t => elt;

let max_elt_opt: t => option(elt);

let choose: t => elt;

let choose_opt: t => option(elt);

let find: elt => t => elt;

let find_opt: elt => t => option(elt);

let find_first: (elt => bool) => t => elt;

let find_first_opt: (elt => bool) => t => option(elt);

let find_last: (elt => bool) => t => elt;

let find_last_opt: (elt => bool) => t => option(elt);

let iter: (elt => unit) => t => unit;

let fold: (elt => 'acc => 'acc) => t => 'acc => 'acc;

let filter: (elt => bool) => t => t;

let filter_map: (elt => option(elt)) => t => t;

let partition: (elt => bool) => t => (t, t);

let split: elt => t => (t, bool, t);

let is_empty: t => bool;

let mem: elt => t => bool;

let equal: t => t => bool;

let compare: t => t => int;

let subset: t => t => bool;

let for_all: (elt => bool) => t => bool;

let exists: (elt => bool) => t => bool;

let to_list: t => list(elt);

let to_seq_from: elt => t => Stdlib.Seq.t(elt);

let to_seq: t => Stdlib.Seq.t(elt);

let to_rev_seq: t => Stdlib.Seq.t(elt);

let add_seq: Stdlib.Seq.t(elt) => t => t;

let of_seq: Stdlib.Seq.t(elt) => t;

let output: Stdlib.out_channel => t => unit;

let print: Stdlib.Format.formatter => t => unit;

let to_string: t => string;

let of_list: list(elt) => t;

let map: (elt => elt) => t => t;