Module Core.NothingSource

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

The same as unreachable_code, but for local ts.

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 _.