Core.Nothing
SourceThis module extends Base.Nothing
.
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.
Similar arguments apply for other derivers, like globalize
and sexp_grammar
.
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 Base.Identifiable.S with type t := t
include Sexplib0.Sexpable.S with type t := t
include Base.Stringable.S with type t := t
include Base.Comparable.S with type t := t
include Base.Comparisons.S with type t := t
include Base.Comparisons.Infix with type t := t
include Base.Comparator.S with type t := t
include Base.Pretty_printer.S with type t := t
Ignores None
and guarantees there is no Some _
. A better replacement for ignore
.
Ignores []
and guarantees there is no _ :: _
. A better replacement for ignore
.
Returns ok
from Ok ok
and guarantees there is no Error _
.
Returns err
from Error err
and guarantees there is no Ok _
.
Returns fst
from First fst
and guarantees there is no Second _
.
Returns snd
from Second snd
and guarantees there is no First _
.
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
and type comparator_witness := comparator_witness
include Bin_prot.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
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.
include Ppx_hash_lib.Hashable.S with type t := t
include Sexplib0.Sexpable.S with type t := t
include Ppx_compare_lib.Comparable.S with type t := t
include Ppx_hash_lib.Hashable.S with type t := t
include Base.Pretty_printer.S with type t := t
include Comparable.S_binable
with type t := t
with type comparator_witness := comparator_witness
include Base.Comparable.S
with type t := t
with type comparator_witness := comparator_witness
include Base.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 t2
.
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.
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)
.
include Base.Comparator.S
with type t := t
with type comparator_witness := comparator_witness
include Comparator.S
with type t := t
with type comparator_witness := comparator_witness
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