Module Core_kernel.Ordering

Extends Base.Ordering, intended to make code that matches on the result of a comparison more concise and easier to read.

type t = Base.Ordering.t =
| Less
| Equal
| Greater
include sig ... end
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (Core_kernel__.Import.int ‑> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val compare : t ‑> t ‑> Core_kernel__.Import.int
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
val t_of_sexp : Base.Sexp.t ‑> t
val sexp_of_t : t ‑> Base.Sexp.t
include module type of Base.Ordering with type Ordering.t := t

Ordering is intended to make code that matches on the result of a comparison more concise and easier to read.

For example, instead of writing:

      let r = compare x y in
      if r < 0 then
        ...
      else if r = 0 then
        ...
      else
        ...

you could simply write:

      match Ordering.of_int (compare x y) with
      | Less -> ...
      | Equal -> ...
      | Greater -> ...
type t =
| Less
| Equal
| Greater
include sig ... end
val compare : t ‑> t ‑> int
val all : t list
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
val t_of_sexp : Base.Sexp.t ‑> t
val sexp_of_t : t ‑> Base.Sexp.t
include Base.Equal.S with type t := t
type t
val equal : t Base.Equal.equal
val of_int : int ‑> t

of_int n is:

      Less     if n < 0
      Equal    if n = 0
      Greater  if n > 0
val to_int : t ‑> int

to_int t is:

      Less     -> -1
      Equal    -> 0
      Greater  -> 1

It can be useful when writing a comparison function to allow one to return Ordering.t values and transform them to ints later.

module Export = Base.Ordering.Export