# Module `Core_kernel.Nothing`

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.

For instance, `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.

`type t`

`=`

Having

`[@@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

`Nothing.t`

, but`[@@deriving 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 hash_fold_t : Base.Hash.state -> t -> Base.Hash.state`

`val hash : t -> Base.Hash.hash_value`

`val all : t Core_kernel__.Import.list`

`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 `Identifiable.S`

here.

Obviously, `of_string`

and `t_of_sexp`

will raise an exception.

`include Identifiable.S with type t := t`

`include Bin_prot.Binable.S with type t := t`

`include Bin_prot.Binable.S_only_functions with type t := t`

`val bin_size_t : t Bin_prot.Size.sizer`

`val bin_write_t : t Bin_prot.Write.writer`

`val bin_read_t : t Bin_prot.Read.reader`

`val __bin_read_t__ : (int -> t) Bin_prot.Read.reader`

This function only needs implementation if

`t`

exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant`t`

afterwards.

`val bin_shape_t : Bin_prot.Shape.t`

`val bin_writer_t : t Bin_prot.Type_class.writer`

`val bin_reader_t : t Bin_prot.Type_class.reader`

`val bin_t : t Bin_prot.Type_class.t`

`val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state`

`val hash : t -> Base.Hash.hash_value`

`include Ppx_sexp_conv_lib.Sexpable.S with type t := t`

`val t_of_sexp : Sexplib0.Sexp.t -> t`

`val sexp_of_t : t -> Sexplib0.Sexp.t`

`include Identifiable.S_common with type t := 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 sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t`

`include Core_kernel__.Import.Stringable.S with type t := t`

`include Core_kernel__.Import.Pretty_printer.S with type t := t`

`val pp : Base.Formatter.t -> t -> unit`

`include Comparable.S_binable with type t := t`

`include Core_kernel__.Comparable_intf.S_common`

`include Base.Comparable.S`

`include Base__.Comparable_intf.Polymorphic_compare`

`val ascending : t -> t -> int`

`ascending`

is identical to`compare`

.`descending x y = ascending y x`

. These are intended to be mnemonic when used like`List.sort ~compare:ascending`

and`List.sort ~cmp:descending`

, since they cause the list to be sorted in ascending or descending order, respectively.

`val descending : t -> t -> int`

`val between : t -> low:t -> high:t -> bool`

`between t ~low ~high`

means`low <= t <= high`

`val clamp_exn : t -> min:t -> max:t -> t`

`clamp_exn t ~min ~max`

returns`t'`

, the closest value to`t`

such that`between t' ~low:min ~high:max`

is true.Raises if

`not (min <= max)`

.

`val clamp : t -> min:t -> max:t -> t Base.Or_error.t`

`include Base.Comparator.S with type t := t`

`val comparator : (t, comparator_witness) Base.Comparator.comparator`

`include Base__.Comparable_intf.Validate with type t := t`

`val validate_lbound : min:t Base.Maybe_bound.t -> t Base.Validate.check`

`val validate_ubound : max:t Base.Maybe_bound.t -> t Base.Validate.check`

`val validate_bound : min:t Base.Maybe_bound.t -> max:t Base.Maybe_bound.t -> t Base.Validate.check`

`module Replace_polymorphic_compare : Core_kernel__.Comparable_intf.Polymorphic_compare with type t := t`

`include Core_kernel__.Comparable_intf.Map_and_set_binable with type t := t with type comparator_witness := comparator_witness`

`include Comparator.S with type t := t`

`val comparator : (t, comparator_witness) Comparator.comparator`

`module Map : Map.S_binable with type Key.t = t with type Key.comparator_witness = comparator_witness`

`module Set : Set.S_binable with type Elt.t = t with type Elt.comparator_witness = comparator_witness`

`include Hashable.S_binable with type t := t`

`val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state`

`val hash : t -> Base.Hash.hash_value`

`val hashable : t Hashtbl.Hashable.t`

`module Table : Hashtbl.S_binable with type key = t`

`module Hash_set : Hash_set.S_binable with type elt = t`

`module Hash_queue : Hash_queue.S with type key = t`

`module Stable : sig ... end`