package core

  1. Overview
  2. Docs

Module Core.ComparableSource

Comparable extends Base.Comparable and provides functions for comparing like types.

Usage example:

  module Foo = struct
    module T = struct
      type t = ... [@@deriving compare, sexp]
    end
    include T
    include Comparable.Make (T)
  end

Then include Comparable.S in the signature (see Comparable_intf 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)
Sourcemodule type Infix = Base.Comparable.Infix
Sourcemodule type Map_and_set_binable = sig ... end
Sourcemodule type Polymorphic_compare = Base.Comparable.Polymorphic_compare
Sourcemodule type S_plain = sig ... end
Sourcemodule type S = sig ... end
Sourcemodule type S_binable = sig ... end
Sourcemodule type S_common = sig ... end
Sourcemodule type Validate = sig ... end
Sourcemodule type Validate_with_zero = sig ... end
Sourcemodule type With_compare = Base.Comparable.With_compare
Sourcemodule type With_zero = sig ... end
include With_compare
Sourceval lexicographic : ('a -> 'a -> int) list -> 'a -> 'a -> int

lexicographic cmps x y compares x and y lexicographically using functions in the list cmps.

Sourceval lift : ('a -> 'a -> 'result) -> f:('b -> 'a) -> 'b -> 'b -> 'result

lift cmp ~f x y compares x and y by comparing f x and f y via cmp.

Sourceval reverse : ('a -> 'a -> 'result) -> 'a -> 'a -> 'result

reverse cmp x y = cmp y x

Reverses the direction of asymmetric relations by swapping their arguments. Useful, e.g., for relations implementing "is a subset of" or "is a descendant of".

Where reversed relations are already provided, use them directly. For example, Comparable.S provides ascending and descending, which are more readable as a pair than compare and reverse compare. Similarly, <= is more idiomatic than reverse (>=).

The functions below are analogues of the type-specific functions exported by the Comparable.S interface.

Sourceval equal : ('a -> 'a -> int) -> 'a -> 'a -> bool
Sourceval max : ('a -> 'a -> int) -> 'a -> 'a -> 'a
Sourceval min : ('a -> 'a -> int) -> 'a -> 'a -> 'a
Sourcemodule Inherit (C : sig ... end) (T : sig ... end) : S with type t := T.t

Inherit comparability from a component.

Comparison-only Functors

These functors require only type t and val compare. They do not require val sexp_of_t, and do not generate container datatypes.

Sourcemodule Infix (T : sig ... end) : Infix with type t := T.t
Sourcemodule Polymorphic_compare (T : sig ... end) : Polymorphic_compare with type t := T.t

Make Functors

The Comparable Make functor family allows users to choose among the following attributes:

  • *_using_comparator or not
  • *_binable or not
  • *_plain or not

Thus there are functors like Make_plain or Make_binable_using_comparator, etc.

Sourcemodule Make_plain (T : sig ... end) : S_plain with type t := T.t
Sourcemodule Make (T : sig ... end) : S with type t := T.t
Sourcemodule Make_plain_using_comparator (T : sig ... end) : S_plain with type t := T.t with type comparator_witness := T.comparator_witness
Sourcemodule Make_using_comparator (T : sig ... end) : S with type t := T.t with type comparator_witness := T.comparator_witness
Sourcemodule Make_binable (T : sig ... end) : S_binable with type t := T.t
Sourcemodule Extend (M : Base.Comparable.S) (X : sig ... end) : S with type t := M.t with type comparator_witness := M.comparator_witness
Sourcemodule Extend_binable (M : Base.Comparable.S) (X : sig ... end) : S_binable with type t := M.t with type comparator_witness := M.comparator_witness
Sourcemodule Map_and_set_binable (T : sig ... end) : Map_and_set_binable with type t := T.t
Sourcemodule Poly (T : sig ... end) : S with type t := T.t
Sourcemodule Validate (T : sig ... end) : Validate with type t := T.t
Sourcemodule Validate_with_zero (T : sig ... end) : Validate_with_zero with type t := T.t
Sourcemodule With_zero (T : sig ... end) : With_zero with type t := T.t

The following module types and functors may be used to define stable modules:

Sourcemodule Stable : sig ... end