sig
  module Set :
    functor (E : Cf_ordered.Total_T->
      sig
        type t
        module Element : sig type t = E.t val compare : t -> t -> int end
        val nil : t
        val empty : t -> bool
        val size : t -> int
        val member : Element.t -> t -> bool
        val singleton : Element.t -> t
        val min : t -> Element.t
        val max : t -> Element.t
        val put : Element.t -> t -> t
        val clear : Element.t -> t -> t
        val union : t -> t -> t
        val diff : t -> t -> t
        val intersect : t -> t -> t
        val compare : t -> t -> int
        val subset : t -> t -> bool
        val of_list : Element.t list -> t
        val of_list_incr : Element.t list -> t
        val of_list_decr : Element.t list -> t
        val of_seq : Element.t Cf_seq.t -> t
        val of_seq_incr : Element.t Cf_seq.t -> t
        val of_seq_decr : Element.t Cf_seq.t -> t
        val to_list_incr : t -> Element.t list
        val to_list_decr : t -> Element.t list
        val to_seq_incr : t -> Element.t Cf_seq.t
        val to_seq_decr : t -> Element.t Cf_seq.t
        val nearest_decr : Element.t -> t -> Element.t Cf_seq.t
        val nearest_incr : Element.t -> t -> Element.t Cf_seq.t
        val iterate : (Element.t -> unit) -> t -> unit
        val predicate : (Element.t -> bool) -> t -> bool
        val fold : ('-> Element.t -> 'a) -> '-> t -> 'a
        val filter : (Element.t -> bool) -> t -> t
        val partition : (Element.t -> bool) -> t -> t * t
      end
  module Map :
    functor (K : Cf_ordered.Total_T->
      sig
        type +'a t
        module Key : sig type t = K.t val compare : t -> t -> int end
        val nil : 'a t
        val empty : 'a t -> bool
        val size : 'a t -> int
        val min : 'a t -> Key.t * 'a
        val max : 'a t -> Key.t * 'a
        val search : Key.t -> 'a t -> 'a
        val member : Key.t -> 'a t -> bool
        val insert : Key.t * '-> 'a t -> 'a t * 'a option
        val replace : Key.t * '-> 'a t -> 'a t
        val modify : Key.t -> ('-> 'a) -> 'a t -> 'a t
        val extract : Key.t -> 'a t -> 'a * 'a t
        val delete : Key.t -> 'a t -> 'a t
        val of_list : (Key.t * 'a) list -> 'a t
        val of_list_incr : (Key.t * 'a) list -> 'a t
        val of_list_decr : (Key.t * 'a) list -> 'a t
        val of_seq : (Key.t * 'a) Cf_seq.t -> 'a t
        val of_seq_incr : (Key.t * 'a) Cf_seq.t -> 'a t
        val of_seq_decr : (Key.t * 'a) Cf_seq.t -> 'a t
        val to_list_incr : 'a t -> (Key.t * 'a) list
        val to_list_decr : 'a t -> (Key.t * 'a) list
        val to_seq_incr : 'a t -> (Key.t * 'a) Cf_seq.t
        val to_seq_decr : 'a t -> (Key.t * 'a) Cf_seq.t
        val nearest_decr : Key.t -> 'a t -> (Key.t * 'a) Cf_seq.t
        val nearest_incr : Key.t -> 'a t -> (Key.t * 'a) Cf_seq.t
        val iterate : (Key.t * '-> unit) -> 'a t -> unit
        val predicate : (Key.t * '-> bool) -> 'a t -> bool
        val fold : ('-> Key.t * '-> 'b) -> '-> 'a t -> 'b
        val filter : (Key.t * '-> bool) -> 'a t -> 'a t
        val map : (Key.t * '-> 'b) -> 'a t -> 'b t
        val optmap : (Key.t * '-> 'b option) -> 'a t -> 'b t
        val partition : (Key.t * '-> bool) -> 'a t -> 'a t * 'a t
      end
end