Defines functors for making modules comparable.
Usage example:
module Foo = struct
module T = struct
type t = ... [@@deriving_inline compare, sexp][@@@end]
end
include T
include Comparable.Make (T)
end
Then include Comparable.S
in the signature
module Foo : sig
type t = ...
include Comparable.S with type t := t
end
To add an Infix
submodule:
module C = Comparable.Make (T)
include C
module Infix = (C : Comparable.Infix with type t := t)
A common pattern is to 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)
module type Infix = Base__.Comparable_intf.Infix
module type S = Base__.Comparable_intf.S
module type Validate = Base__.Comparable_intf.Validate
module type With_zero = Base__.Comparable_intf.With_zero
val lexicographic : ('a ‑> 'a ‑> int) list ‑> 'a ‑> 'a ‑> int
lexicographic cmps x y
compares x
and y
lexicographically using functions in the
list cmps
.
val lift : ('a ‑> 'a ‑> 'int_or_bool) ‑> f:('b ‑> 'a) ‑> 'b ‑> 'b ‑> 'int_or_bool
lift cmp ~f x y
compares x
and y
by comparing f x
and f y
via cmp
.
module Make_using_comparator : functor (T : sig ... end) -> S with type t := T.t with type comparator_witness := T.comparator_witness
module Validate_with_zero : functor (T : sig ... end) -> sig ... end