package core_kernel

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

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 = (Base.Unit.t, Base.Int.t) Typerep_lib.Std.Type_equal.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.

include sig ... end
val all : t Base.List.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 Identifiable.S here.

Obviously, of_string and t_of_sexp will raise an exception.

include Identifiable.S with type t := t
include sig ... end
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (Base.Int.t -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
include Identifiable.S_common with type t := t
include sig ... end
val sexp_of_t : t -> Sexplib.Sexp.t
val of_string : string -> t
val to_string : t -> string
val pp : Base__.Import.Caml.Format.formatter -> t -> unit
include Comparable.S_binable with type t := t
include Base.Comparable_intf.S with type t := t
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (<>) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
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 = Nothing.Replace_polymorphic_compare
include Comparator.S with type t := t with type comparator_witness := comparator_witness
module Map : sig ... end
module Set : sig ... end
include Hashable.S_binable with type t := t
include sig ... end
val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core_kernel__.Hashtbl.Hashable.t
module Table : sig ... end
module Hash_set : sig ... end
module Hash_queue : sig ... end
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