# 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 -> intend) -> 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)

Parameters:

`T` | : | `sig type t with compare, sexp end`

    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