package core

  1. Overview
  2. Docs
package core
Legend:
Library
Module
Module type
Parameter
Class
Class type

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)
module type Infix = Base.Comparable.Infix
module type Map_and_set_binable = sig ... end
module type Polymorphic_compare = Base.Comparable.Polymorphic_compare
module type S_plain = sig ... end
module type S = sig ... end
module type S_binable = sig ... end
module type S_common = sig ... end
module type Validate = sig ... end
module type Validate_with_zero = sig ... end
module type With_compare = Base.Comparable.With_compare
module type With_zero = sig ... end
include With_compare
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 -> '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.

val 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.

val equal : ('a -> 'a -> int) -> 'a -> 'a -> bool
val max : ('a -> 'a -> int) -> 'a -> 'a -> 'a
val min : ('a -> 'a -> int) -> 'a -> 'a -> 'a
module 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.

module Infix (T : sig ... end) : Infix with type t := T.t
module 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.

module Make_plain (T : sig ... end) : S_plain with type t := T.t
module Make (T : sig ... end) : S with type t := T.t
module Make_plain_using_comparator (T : sig ... end) : S_plain with type t := T.t with type comparator_witness := T.comparator_witness
module Make_using_comparator (T : sig ... end) : S with type t := T.t with type comparator_witness := T.comparator_witness
module Make_binable (T : sig ... end) : S_binable with type t := T.t
module Make_binable_using_comparator (T : sig ... end) : S_binable with type t := T.t with type comparator_witness := T.comparator_witness
module Extend (M : Base.Comparable.S) (X : sig ... end) : S with type t := M.t with type comparator_witness := M.comparator_witness
module Extend_binable (M : Base.Comparable.S) (X : sig ... end) : S_binable with type t := M.t with type comparator_witness := M.comparator_witness
module Map_and_set_binable (T : sig ... end) : Map_and_set_binable with type t := T.t
module Poly (T : sig ... end) : S with type t := T.t
module Validate (T : sig ... end) : Validate with type t := T.t
module Validate_with_zero (T : sig ... end) : Validate_with_zero with type t := T.t
module 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:

module Stable : sig ... end
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct