sig
module Raw :
sig
type ('base, 'set) t = private
Base of 'base
| Set of 'set
| Union of ('base, 'set) Set_lang.Raw.t *
('base, 'set) Set_lang.Raw.t
| Inter of ('base, 'set) Set_lang.Raw.t *
('base, 'set) Set_lang.Raw.t
| Diff of ('base, 'set) Set_lang.Raw.t * ('base, 'set) Set_lang.Raw.t
val compare :
('base -> 'base -> int) ->
('set -> 'set -> int) ->
('base, 'set) Set_lang.Raw.t -> ('base, 'set) Set_lang.Raw.t -> int
end
type ('base, 'elt, 'cmp) t =
('base, ('elt, 'cmp) Core.Std.Set.t) Set_lang.Raw.t
val base : 'base -> ('base, 'a, 'b) Set_lang.t
val set : ('elt, 'cmp) Core.Std.Set.t -> ('a, 'elt, 'cmp) Set_lang.t
val inter2 :
('b, 'e, 'c) Set_lang.t ->
('b, 'e, 'c) Set_lang.t -> ('b, 'e, 'c) Set_lang.t
val union2 :
('b, 'e, 'c) Set_lang.t ->
('b, 'e, 'c) Set_lang.t -> ('b, 'e, 'c) Set_lang.t
val diff :
('b, 'e, 'c) Set_lang.t ->
('b, 'e, 'c) Set_lang.t -> ('b, 'e, 'c) Set_lang.t
val union :
('b, 'e, 'c) Set_lang.t * ('b, 'e, 'c) Set_lang.t list ->
('b, 'e, 'c) Set_lang.t
val inter :
('b, 'e, 'c) Set_lang.t * ('b, 'e, 'c) Set_lang.t list ->
('b, 'e, 'c) Set_lang.t
val union_list :
('b, 'e, 'c) Set_lang.t list ->
('b, 'e, 'c) Set_lang.t Core.Std.Or_error.t
val inter_list :
('b, 'e, 'c) Set_lang.t list ->
('b, 'e, 'c) Set_lang.t Core.Std.Or_error.t
val union_list_exn :
('b, 'e, 'c) Set_lang.t list -> ('b, 'e, 'c) Set_lang.t
val inter_list_exn :
('b, 'e, 'c) Set_lang.t list -> ('b, 'e, 'c) Set_lang.t
val values : ('base, 'a, 'b) Set_lang.t -> 'base list
val constant_value :
('a, 'elt, 'cmp) Set_lang.t -> ('elt, 'cmp) Core.Std.Set.t option
val subst :
('b1, 'e, 'c) Set_lang.t ->
f:('b1 -> ('b2, 'e, 'c) Set_lang.t) -> ('b2, 'e, 'c) Set_lang.t
val map :
('b1, 'e, 'c) Set_lang.t -> f:('b1 -> 'b2) -> ('b2, 'e, 'c) Set_lang.t
val specialize :
('b, 'e, 'c) Set_lang.t ->
f:('b -> ('e, 'c) Core.Std.Set.t option) -> ('b, 'e, 'c) Set_lang.t
val eval :
('b, 'e, 'c) Set_lang.t ->
f:('b -> ('e, 'c) Core.Std.Set.t) -> ('e, 'c) Core.Std.Set.t
val invariant : ('base, 'elt, 'cmp) Set_lang.t -> unit
module Make_monadic_eval :
functor (M : Core.Std.Monad.S) ->
sig
val subst :
('b, 'e, 'c) Set_lang.t ->
f:('b -> ('b, 'e, 'c) Set_lang.t M.t) ->
('b, 'e, 'c) Set_lang.t M.t
val map :
('b, 'e, 'c) Set_lang.t ->
f:('b -> 'b M.t) -> ('b, 'e, 'c) Set_lang.t M.t
val specialize :
('b, 'e, 'c) Set_lang.t ->
f:('b -> ('e, 'c) Core.Std.Set.t option M.t) ->
('b, 'e, 'c) Set_lang.t M.t
val eval :
('b, 'e, 'c) Set_lang.t ->
f:('b -> ('e, 'c) Core.Std.Set.t M.t) ->
('e, 'c) Core.Std.Set.t M.t
end
module type S =
sig
module Set : Core.Std.Set.S
type 'base t = ('base, Set.t) Raw.t
val base : 'base -> 'base t
val set : Set.t -> 'a t
val inter2 : 'b t -> 'b t -> 'b t
val union2 : 'b t -> 'b t -> 'b t
val diff : 'b t -> 'b t -> 'b t
val union : 'b t list -> 'b t
val inter : 'b t * 'b t list -> 'b t
val inter_list : 'b t list -> 'b t Core.Std.Or_error.t
val inter_list_exn : 'b t list -> 'b t
val values : 'base t -> 'base list
val constant_value : 'a t -> Set.t option
val subst :
'b1 t ->
f:('b1 -> 'b2 t Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
val map :
'b1 t ->
f:('b1 -> 'b2 Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
val specialize :
'b t ->
f:('b -> Set.t option Set_lang_intf.value) ->
'b t Set_lang_intf.value
val eval :
'b t ->
f:('b -> Set.t Set_lang_intf.value) -> Set.t Set_lang_intf.value
module Make_monadic_eval :
functor (M : Core.Std.Monad.S) ->
sig
val subst : 'b1 t -> f:('b1 -> 'b2 t M.t) -> 'b2 t M.t
val map : 'b1 t -> f:('b1 -> 'b2 M.t) -> 'b2 t M.t
val specialize : 'b t -> f:('b -> Set.t option M.t) -> 'b t M.t
val eval : 'b t -> f:('b -> Set.t M.t) -> Set.t M.t
end
val t_of_sexp : (Sexplib.Sexp.t -> 'base) -> Sexplib.Sexp.t -> 'base t
val sexp_of_t : ('base -> Sexplib.Sexp.t) -> 'base t -> Sexplib.Sexp.t
val compare : ('base -> 'base -> int) -> 'base t -> 'base t -> int
end
module type S_binable =
sig
module Set : Core.Std.Set.S_binable
type 'base t = ('base, Set.t) Raw.t
val base : 'base -> 'base t
val set : Set.t -> 'a t
val inter2 : 'b t -> 'b t -> 'b t
val union2 : 'b t -> 'b t -> 'b t
val diff : 'b t -> 'b t -> 'b t
val union : 'b t list -> 'b t
val inter : 'b t * 'b t list -> 'b t
val inter_list : 'b t list -> 'b t Core.Std.Or_error.t
val inter_list_exn : 'b t list -> 'b t
val values : 'base t -> 'base list
val constant_value : 'a t -> Set.t option
val subst :
'b1 t ->
f:('b1 -> 'b2 t Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
val map :
'b1 t ->
f:('b1 -> 'b2 Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
val specialize :
'b t ->
f:('b -> Set.t option Set_lang_intf.value) ->
'b t Set_lang_intf.value
val eval :
'b t ->
f:('b -> Set.t Set_lang_intf.value) -> Set.t Set_lang_intf.value
module Make_monadic_eval :
functor (M : Core.Std.Monad.S) ->
sig
val subst : 'b1 t -> f:('b1 -> 'b2 t M.t) -> 'b2 t M.t
val map : 'b1 t -> f:('b1 -> 'b2 M.t) -> 'b2 t M.t
val specialize : 'b t -> f:('b -> Set.t option M.t) -> 'b t M.t
val eval : 'b t -> f:('b -> Set.t M.t) -> Set.t M.t
end
val bin_t :
'base Core.Std.Bin_prot.Type_class.t ->
'base t Core.Std.Bin_prot.Type_class.t
val bin_read_t :
'base Core.Std.Bin_prot.Read.reader ->
'base t Core.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'base Core.Std.Bin_prot.Read.reader ->
(int -> 'base t) Core.Std.Bin_prot.Read.reader
val bin_reader_t :
'base Core.Std.Bin_prot.Type_class.reader ->
'base t Core.Std.Bin_prot.Type_class.reader
val bin_size_t :
'base Core.Std.Bin_prot.Size.sizer ->
'base t Core.Std.Bin_prot.Size.sizer
val bin_write_t :
'base Core.Std.Bin_prot.Write.writer ->
'base t Core.Std.Bin_prot.Write.writer
val bin_writer_t :
'base Core.Std.Bin_prot.Type_class.writer ->
'base t Core.Std.Bin_prot.Type_class.writer
val t_of_sexp : (Sexplib.Sexp.t -> 'base) -> Sexplib.Sexp.t -> 'base t
val sexp_of_t : ('base -> Sexplib.Sexp.t) -> 'base t -> Sexplib.Sexp.t
val compare : ('base -> 'base -> int) -> 'base t -> 'base t -> int
end
module Make :
functor (Elt : Core.Std.Comparable.S) ->
sig
module Set :
sig
module Elt :
sig
type t = Elt.t
type comparator_witness = Elt.comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'base t = ('base, Set.t) Raw.t
val base : 'base -> 'base t
val set : Set.t -> 'a t
val inter2 : 'b t -> 'b t -> 'b t
val union2 : 'b t -> 'b t -> 'b t
val diff : 'b t -> 'b t -> 'b t
val union : 'b t list -> 'b t
val inter : 'b t * 'b t list -> 'b t
val inter_list : 'b t list -> 'b t Core.Std.Or_error.t
val inter_list_exn : 'b t list -> 'b t
val values : 'base t -> 'base list
val constant_value : 'a t -> Set.t option
val subst :
'b1 t ->
f:('b1 -> 'b2 t Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
val map :
'b1 t ->
f:('b1 -> 'b2 Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
val specialize :
'b t ->
f:('b -> Set.t option Set_lang_intf.value) ->
'b t Set_lang_intf.value
val eval :
'b t ->
f:('b -> Set.t Set_lang_intf.value) -> Set.t Set_lang_intf.value
module Make_monadic_eval :
functor (M : Core.Std.Monad.S) ->
sig
val subst : 'b1 t -> f:('b1 -> 'b2 t M.t) -> 'b2 t M.t
val map : 'b1 t -> f:('b1 -> 'b2 M.t) -> 'b2 t M.t
val specialize : 'b t -> f:('b -> Set.t option M.t) -> 'b t M.t
val eval : 'b t -> f:('b -> Set.t M.t) -> Set.t M.t
end
val t_of_sexp :
(Sexplib.Sexp.t -> 'base) -> Sexplib.Sexp.t -> 'base t
val sexp_of_t :
('base -> Sexplib.Sexp.t) -> 'base t -> Sexplib.Sexp.t
val compare : ('base -> 'base -> int) -> 'base t -> 'base t -> int
end
module Make_binable :
functor (Elt : Core.Std.Comparable.S_binable) ->
sig
module Set :
sig
module Elt :
sig
type t = Elt.t
type comparator_witness = Elt.comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t ->
(Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val symmetric_diff :
t ->
t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * Elt.t option * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?order:[ `Decreasing | `Increasing ] ->
?greater_or_equal_to:Elt.t ->
?less_or_equal_to:Elt.t -> t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
type 'base t = ('base, Set.t) Raw.t
val base : 'base -> 'base t
val set : Set.t -> 'a t
val inter2 : 'b t -> 'b t -> 'b t
val union2 : 'b t -> 'b t -> 'b t
val diff : 'b t -> 'b t -> 'b t
val union : 'b t list -> 'b t
val inter : 'b t * 'b t list -> 'b t
val inter_list : 'b t list -> 'b t Core.Std.Or_error.t
val inter_list_exn : 'b t list -> 'b t
val values : 'base t -> 'base list
val constant_value : 'a t -> Set.t option
val subst :
'b1 t ->
f:('b1 -> 'b2 t Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
val map :
'b1 t ->
f:('b1 -> 'b2 Set_lang_intf.value) -> 'b2 t Set_lang_intf.value
val specialize :
'b t ->
f:('b -> Set.t option Set_lang_intf.value) ->
'b t Set_lang_intf.value
val eval :
'b t ->
f:('b -> Set.t Set_lang_intf.value) -> Set.t Set_lang_intf.value
module Make_monadic_eval :
functor (M : Core.Std.Monad.S) ->
sig
val subst : 'b1 t -> f:('b1 -> 'b2 t M.t) -> 'b2 t M.t
val map : 'b1 t -> f:('b1 -> 'b2 M.t) -> 'b2 t M.t
val specialize : 'b t -> f:('b -> Set.t option M.t) -> 'b t M.t
val eval : 'b t -> f:('b -> Set.t M.t) -> Set.t M.t
end
val bin_t :
'base Core.Std.Bin_prot.Type_class.t ->
'base t Core.Std.Bin_prot.Type_class.t
val bin_read_t :
'base Core.Std.Bin_prot.Read.reader ->
'base t Core.Std.Bin_prot.Read.reader
val __bin_read_t__ :
'base Core.Std.Bin_prot.Read.reader ->
(int -> 'base t) Core.Std.Bin_prot.Read.reader
val bin_reader_t :
'base Core.Std.Bin_prot.Type_class.reader ->
'base t Core.Std.Bin_prot.Type_class.reader
val bin_size_t :
'base Core.Std.Bin_prot.Size.sizer ->
'base t Core.Std.Bin_prot.Size.sizer
val bin_write_t :
'base Core.Std.Bin_prot.Write.writer ->
'base t Core.Std.Bin_prot.Write.writer
val bin_writer_t :
'base Core.Std.Bin_prot.Type_class.writer ->
'base t Core.Std.Bin_prot.Type_class.writer
val t_of_sexp :
(Sexplib.Sexp.t -> 'base) -> Sexplib.Sexp.t -> 'base t
val sexp_of_t :
('base -> Sexplib.Sexp.t) -> 'base t -> Sexplib.Sexp.t
val compare : ('base -> 'base -> int) -> 'base t -> 'base t -> int
end
val compare :
('base -> 'base -> int) ->
('elt -> 'elt -> int) ->
('cmp -> 'cmp -> int) ->
('base, 'elt, 'cmp) Set_lang.t -> ('base, 'elt, 'cmp) Set_lang.t -> int
end