package core_kernel

  1. Overview
  2. Docs
On This Page
  1. Make Functors
package core_kernel
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 = Comparable.Infix
module type Polymorphic_compare = Comparable.Polymorphic_compare
module type S = Comparable.S
module type Validate = Comparable.Validate
module type With_zero = Comparable.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.

val reverse : ('a -> 'a -> 'int_or_bool) -> 'a -> 'a -> 'int_or_bool

reverse cmp x y = cmp y x

Note: The Comparable.S interface exports both ascending and descending comparisons, so in most cases, it's better to use those.

module Inherit (C : sig ... end) (T : sig ... end) : sig ... end

Inherit comparability from a component.

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) : sig ... end
module Make (T : sig ... end) : sig ... end
module Make_plain_using_comparator (T : sig ... end) : sig ... end
module Make_using_comparator (T : sig ... end) : sig ... end
module Make_binable (T : sig ... end) : sig ... end
module Make_binable_using_comparator (T : sig ... end) : sig ... end
module Extend (M : Base.Comparable.S) (X : sig ... end) : sig ... end
module Extend_binable (M : Base.Comparable.S) (X : sig ... end) : sig ... end
module Map_and_set_binable (T : sig ... end) : sig ... end
module Map_and_set_binable_using_comparator (T : sig ... end) : sig ... end
module Poly (T : sig ... end) : sig ... end
module Validate (T : sig ... end) : sig ... end
module With_zero (T : sig ... end) : sig ... end
module Validate_with_zero (T : sig ... end) : sig ... end

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