functor
  (T : sig
         type t
         val t_of_sexp : Sexplib.Sexp.t -> Comparable.Poly.t
         val sexp_of_t : Comparable.Poly.t -> Sexplib.Sexp.t
       end) ->
  sig
    val ( >= ) : T.t -> T.t -> bool
    val ( <= ) : T.t -> T.t -> bool
    val ( = ) : T.t -> T.t -> bool
    val ( > ) : T.t -> T.t -> bool
    val ( < ) : T.t -> T.t -> bool
    val ( <> ) : T.t -> T.t -> bool
    val equal : T.t -> T.t -> bool
    val compare : T.t -> T.t -> int
    val min : T.t -> T.t -> T.t
    val max : T.t -> T.t -> T.t
    val ascending : T.t -> T.t -> int
    val descending : T.t -> T.t -> int
    val between : T.t -> low:T.t -> high:T.t -> bool
    module Replace_polymorphic_compare :
      sig
        val ( >= ) : T.t -> T.t -> bool
        val ( <= ) : T.t -> T.t -> bool
        val ( = ) : T.t -> T.t -> bool
        val ( > ) : T.t -> T.t -> bool
        val ( < ) : T.t -> T.t -> bool
        val ( <> ) : T.t -> T.t -> bool
        val equal : T.t -> T.t -> bool
        val compare : T.t -> T.t -> int
        val min : T.t -> T.t -> T.t
        val max : T.t -> T.t -> T.t
        val _squelch_unused_module_warning_ : unit
      end
    type comparator
    val comparator : (T.t, comparator) Comparator.t
    val validate_lbound : min:T.t Comparable_intf.bound -> T.t Validate.check
    val validate_ubound : max:T.t Comparable_intf.bound -> T.t Validate.check
    val validate_bound :
      min:T.t Comparable_intf.bound ->
      max:T.t Comparable_intf.bound -> T.t Validate.check
    module Map :
      sig
        module Key :
          sig
            type t = T.t
            val compare : t -> t -> int
            val t_of_sexp : Sexplib.Sexp.t -> t
            val sexp_of_t : t -> Sexplib.Sexp.t
            type comparator = comparator
            val comparator : (t, comparator) Comparator.t_
          end
        module Tree :
          sig
            type 'a t = (Key.t, 'a, Key.comparator) Core_map.Tree.t
            val empty : 'a t
            val singleton : Key.t -> 'a -> 'a t
            val of_alist :
              (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
            val of_alist_exn : (Key.t * 'a) list -> 'a t
            val of_alist_multi : (Key.t * 'a) list -> 'a list t
            val of_alist_fold :
              (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
            val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
            val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
            val of_tree : 'a t -> 'a t
            val invariants : 'a t -> bool
            val is_empty : 'a t -> bool
            val length : 'a t -> int
            val add : 'a t -> key:Key.t -> data:'a -> 'a t
            val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
            val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
            val find : 'a t -> Key.t -> 'a option
            val find_exn : 'a t -> Key.t -> 'a
            val remove : 'a t -> Key.t -> 'a t
            val mem : 'a t -> Key.t -> bool
            val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
            val iter2 :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 unit) ->
              unit
            val map : 'a t -> f:('a -> 'b) -> 'b t
            val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
            val fold :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val fold_right :
              'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
            val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
            val filter_mapi :
              'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
            val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
            val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
            val keys : 'a t -> Key.t list
            val data : 'a t -> 'a list
            val to_alist : 'a t -> (Key.t * 'a) list
            val validate :
              name:(Key.t -> string) ->
              'a Validate.check -> 'a t Validate.check
            val merge :
              'a t ->
              'b t ->
              f:(key:Key.t ->
                 [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                 'c option) ->
              'c t
            val symmetric_diff :
              'a t ->
              'a t ->
              data_equal:('a -> 'a -> bool) ->
              (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
              list
            val min_elt : 'a t -> (Key.t * 'a) option
            val min_elt_exn : 'a t -> Key.t * 'a
            val max_elt : 'a t -> (Key.t * 'a) option
            val max_elt_exn : 'a t -> Key.t * 'a
            val for_all : 'a t -> f:('a -> bool) -> bool
            val exists : 'a t -> f:('a -> bool) -> bool
            val fold_range_inclusive :
              'a t ->
              min:Key.t ->
              max:Key.t ->
              init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
            val range_to_alist :
              'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
            val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
            val next_key : 'a t -> Key.t -> (Key.t * 'a) option
            val rank : 'a t -> Key.t -> int option
            val to_tree : 'a t -> 'a t
            val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
            val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          end
        type 'a t = (Key.t, 'a, Key.comparator) Core_map.t
        val empty : 'a t
        val singleton : Key.t -> 'a -> 'a t
        val of_alist :
          (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
        val of_alist_exn : (Key.t * 'a) list -> 'a t
        val of_alist_multi : (Key.t * 'a) list -> 'a list t
        val of_alist_fold :
          (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
        val of_sorted_array : (Key.t * 'a) array -> 'a t Or_error.t
        val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
        val of_tree : 'a Tree.t -> 'a t
        val invariants : 'a t -> bool
        val is_empty : 'a t -> bool
        val length : 'a t -> int
        val add : 'a t -> key:Key.t -> data:'a -> 'a t
        val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
        val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
        val find : 'a t -> Key.t -> 'a option
        val find_exn : 'a t -> Key.t -> 'a
        val remove : 'a t -> Key.t -> 'a t
        val mem : 'a t -> Key.t -> bool
        val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
        val iter2 :
          'a t ->
          'b t ->
          f:(key:Key.t ->
             data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
          unit
        val map : 'a t -> f:('a -> 'b) -> 'b t
        val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
        val fold :
          'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
        val fold_right :
          'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
        val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
        val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
        val filter_mapi :
          'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
        val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
        val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
        val keys : 'a t -> Key.t list
        val data : 'a t -> 'a list
        val to_alist : 'a t -> (Key.t * 'a) list
        val validate :
          name:(Key.t -> string) -> 'a Validate.check -> 'a t Validate.check
        val merge :
          'a t ->
          'b t ->
          f:(key:Key.t ->
             [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
          'c t
        val symmetric_diff :
          'a t ->
          'a t ->
          data_equal:('a -> 'a -> bool) ->
          (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) list
        val min_elt : 'a t -> (Key.t * 'a) option
        val min_elt_exn : 'a t -> Key.t * 'a
        val max_elt : 'a t -> (Key.t * 'a) option
        val max_elt_exn : 'a t -> Key.t * 'a
        val for_all : 'a t -> f:('a -> bool) -> bool
        val exists : 'a t -> f:('a -> bool) -> bool
        val fold_range_inclusive :
          'a t ->
          min:Key.t ->
          max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
        val range_to_alist :
          'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
        val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
        val next_key : 'a t -> Key.t -> (Key.t * 'a) option
        val rank : 'a t -> Key.t -> int option
        val to_tree : 'a t -> 'a Tree.t
        val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
        val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
        val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
      end
    module Set :
      sig
        module Elt :
          sig
            type t = T.t
            val compare : t -> t -> int
            val t_of_sexp : Sexplib.Sexp.t -> t
            val sexp_of_t : t -> Sexplib.Sexp.t
            type comparator = comparator
            val comparator : (t, comparator) Comparator.t_
          end
        module Tree :
          sig
            type t = (Elt.t, Elt.comparator) 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 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 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 * bool * 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 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 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_set.Tree.t -> f:('a -> Elt.t) -> t
            val filter_map :
              ('a, 'b) Core_set.Tree.t -> f:('a -> Elt.t option) -> t
            val of_tree : 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) 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 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 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 * bool * 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 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 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_set.t -> f:('a -> Elt.t) -> t
        val filter_map : ('a, 'b) Core_set.t -> f:('a -> Elt.t option) -> t
        val of_tree : Tree.t -> t
        val t_of_sexp : Sexplib.Sexp.t -> t
        val sexp_of_t : t -> Sexplib.Sexp.t
        val compare : t -> t -> int
      end
  end