Comparator (core_kernel.Core_kernel.Comparator)

type ('a, 'witness) t = private ('a, 'witness) Base.Comparator.t = {

compare : 'a ‑> 'a ‑> Core_kernel__.Import.int;

sexp_of_t : 'a ‑> Core_kernel__.Import.Sexp.t;

}

include module type of Base.Comparator with type (a, witness) Comparator.t := (a, witness) t

A type-indexed value that allows one to compare (and for generating error messages, serialize) values of the type in question.

One of the type parameters is a phantom parameter used to distinguish comparators potentially built on different comparison functions. In particular, we want to distinguish those using polymorphic compare and those using a monomorphic compare.

type ('a, 'witness) t = private {

compare : 'a ‑> 'a ‑> int;

sexp_of_t : 'a ‑> Base.Sexp.t;

}

type ('a, 'b) comparator = ('a, 'b) t

module type S : sig ... end

module type S1 : sig ... end

module type S_fc : sig ... end

val make : compare:('a ‑> 'a ‑> int) ‑> sexp_of_t:('a ‑> Base.Sexp.t) ‑> (module S_fc with type comparable_t = 'a)

make creates a comparator witness for the given comparison. It is intended as a lightweight alternative to the functors below, to be used like so: include (val Comparator.make ~compare ~sexp_of_t)

module Poly = Base.Comparator.Poly

module S_to_S1 = Base.Comparator.S_to_S1

module Make = Base.Comparator.Make

Make creates a comparator value and its phantom comparator_witness type for a nullary type.

module Make1 = Base.Comparator.Make1

Make1 creates a comparator value and its phantom comparator_witness type for a unary type. It takes a compare and sexp_of_t that have non-standard types because the Comparator.t type doesn't allow passing in additional values for the type argument.