Module Frenetic_netkat.Fdd.Action.Par

include Core.Set.S with type Par.Elt.t = Value.t Seq.t
module Elt : sig ... end
module Tree : sig ... end
type t = (Elt.t, Elt.comparator_witness) Base.Set.t
val compare : t ‑> t ‑> Core_kernel__.Import.int
type named = (Elt.t, Elt.comparator_witness) Core_kernel__.Set_intf.Named.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 fold_result : t ‑> init:'accum ‑> f:('accum ‑> Elt.t ‑> ('accum, 'e) Base__.Result.t) ‑> ('accum, 'e) Base__.Result.t
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 Base__.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) 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]
module Named : sig ... end
val fold_until : t ‑> init:'b ‑> f:('b ‑> Elt.t ‑> ('b, 'final) Base__.Set_intf.Continue_or_stop.t) ‑> finish:('b ‑> 'final) ‑> 'final
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
  • Deprecated [since 2016-10] Use [nth]
val nth : 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 Base__.Sequence.t
val merge_to_sequence : ?⁠order:[ `Decreasing | `Increasing ] ‑> ?⁠greater_or_equal_to:Elt.t ‑> ?⁠less_or_equal_to:Elt.t ‑> t ‑> t ‑> (Elt.t, Elt.t) Base__.Set_intf.Merge_to_sequence_element.t Base__.Sequence.t
val to_map : t ‑> f:(Elt.t ‑> 'data) ‑> (Elt.t, 'data, Elt.comparator_witness) Core_kernel__.Map.t
val obs : Elt.t Core_kernel__.Quickcheck.Observer.t ‑> t Core_kernel__.Quickcheck.Observer.t
val shrinker : Elt.t Core_kernel__.Quickcheck.Shrinker.t ‑> t Core_kernel__.Quickcheck.Shrinker.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 Base__.Or_error.t
val of_sorted_array_unchecked : Elt.t array ‑> t
val of_increasing_iterator_unchecked : len:int ‑> f:(int ‑> Elt.t) ‑> t
val stable_dedup_list : Elt.t list ‑> Elt.t list
val map : ('a, 'b) Base.Set.t ‑> f:('a ‑> Elt.t) ‑> t
val filter_map : ('a, 'b) Base.Set.t ‑> f:('a ‑> Elt.t option) ‑> t
val of_tree : Tree.t ‑> t
val of_hash_set : Elt.t Core_kernel__.Hash_set.t ‑> t
val of_hashtbl_keys : (Elt.t, 'a) Core_kernel__.Hashtbl.t ‑> t
val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel__.Map.t ‑> t
val gen : Elt.t Core_kernel__.Quickcheck.Generator.t ‑> t Core_kernel__.Quickcheck.Generator.t
module Provide_of_sexp : functor (Elt : sig ... end) -> sig ... end
module Provide_bin_io : functor (Elt : sig ... end) -> sig ... end
module Provide_hash : functor (Elt : sig ... end) -> sig ... end
val t_of_sexp : Base__.Ppx_sexp_conv_lib.Sexp.t ‑> t
val sexp_of_t : t ‑> Base__.Ppx_sexp_conv_lib.Sexp.t
val to_hvs : t ‑> (Field.t * Value.t) list

to_hvs s converts to a sequence to an HVS list applying sequences in the right order

val mod_k : t ‑> t
val compare_mod_k : t ‑> t ‑> int
val equal_mod_k : t ‑> t ‑> bool
val to_string : t ‑> string