An uninhabited type. This is useful when interfaces require that a type be specified, but the implementer knows this type will not be used in their implementation of the interface.
Async.Rpc.Pipe_rpc.t is parameterized by an error type, but a user may want to define a Pipe RPC that can't fail.
[@@deriving enumerate] may seem strange due to the fact that generated
val all : t list is the empty list, so it seems like it could be of no use.
This may be true if you always expect your type to be
enumerate] can be useful if you have a type which you expect to change over time. For example, you may have a program which has to interact with multiple servers which are possibly at different versions. It may be useful in this program to have a variant type which enumerates the ways in which the servers may differ. When all the servers are at the same version, you can change this type to
Nothing.t and code which uses an enumeration of the type will continue to work correctly.
This is a similar issue to the identifiability of
Nothing.t. As discussed below, another case where
[@deriving enumerate] could be useful is when this type is part of some larger type.
val all : t list
val t_sexp_grammar : t Sexplib0.Sexp_grammar.t
val unreachable_code : t -> _
Because there are no values of type
Nothing.t, a piece of code that has a value of type
Nothing.t must be unreachable. In such an unreachable piece of code, one can use
unreachable_code to give the code whatever type one needs. For example:
let f (r : (int, Nothing.t) Result.t) : int = match r with | Ok i -> i | Error n -> Nothing.unreachable_code n ;;
Note that the compiler knows that
Nothing.t is uninhabited, hence this will type without warning:
let f (Ok i : (int, Nothing.t) Result.t) = i
It may seem weird that this is identifiable, but we're just trying to anticipate all the contexts in which people may need this. It would be a crying shame if you had some variant type involving
Nothing.t that you wished to make identifiable, but were prevented for lack of
t_of_sexp will raise an exception.
include Identifiable.S with type t := t
val hash_fold_t : Hash.state -> t -> Hash.state
val hash : t -> Hash.hash_value
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
include Stringable.S with type t := t
val of_string : string -> t
val to_string : t -> string
include Comparable.S with type t := t
include Comparisons.S with type t := t
compare t1 t2 returns 0 if
t1 is equal to
t2, a negative integer if
t1 is less than
t2, and a positive integer if
t1 is greater than
ascending is identical to
descending x y = ascending y x. These are intended to be mnemonic when used like
List.sort ~compare:ascending and
~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.
clamp_exn t ~min ~max returns
t', the closest value to
t such that
between t' ~low:min ~high:max is true.
not (min <= max).
val clamp : t -> min:t -> max:t -> t Or_error.t
include Comparator.S with type t := t
val comparator : (t, comparator_witness) Comparator.comparator
include Pretty_printer.S with type t := t
val pp : Formatter.t -> t -> unit
val hashable : t Hashable.t