Functor Comparable.Make

module Make: 
functor (T : sig

type t 


val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end) -> S  with type t := T.t

Usage example:

      module Foo = struct
        module T = struct
          type t = ... with compare, sexp
        end
        include T
        include Comparable.Make (T)
      end
    

Then include Comparable.S in the signature (see comparable_intf.mli for an example).

To add an Infix submodule:

      module C = Comparable.Make (T)
      include C
      module Infix = (C : Comparable.Infix with type t := t)
    

Common pattern: Define a module O with a restricted signature. It aims to be (locally) opened to bring useful operators into scope without shadowing unexpected variable names. E.g. in the Date module:

      module O = struct
        include (C : Comparable.Infix with type t := t)
        let to_string t = ..
      end
    

Opening Date would shadow now, but opening Date.O doesn't:

      let now = .. in
      let someday = .. in
      Date.O.(now > someday)
    

include Comparable_intf.S_common

module Map: Core_map.S 
    with type Key.t = t 
    with type Key.comparator_witness = comparator_witness

module Set: Core_set.S 
    with type Elt.t = t 
    with type Elt.comparator_witness = comparator_witness