Span.Option.t
is like Span.t option
, except that the value is immediate on
architectures where Int63.t
is immediate. This module should mainly be used to
avoid allocations.
include Core__.Time_ns_intf.Option with type value := t
include Core__.Import.Immediate_option.S_int63
type value
The immediate value carried by the immediate option.
Given the presence of unchecked_value, the value
type should not have
operations that depend on the value's validity for memory safety. In particular,
unchecked_value
is not called unsafe_value
as it would be if it could return a
value that later resulted in a segmentation fault. For pointer-like values, use
Zero.Ext.Nullable, for example.
type t
Represents value option
without allocating a Some
tag. The interface does not
enforce that t
is immediate because some types, like Int63.t
, are only immediate
on 64-bit platforms. For representations whose type is immediate, use S
below
which adds the [@@immediate]
annotation.
include sig ... end
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 ‑> Base.Sexp.t
val typerep_of_t : t Typerep_lib.Std.Typerep.t
val typename_of_t : t Typerep_lib.Std.Typename.t
Constructors analogous to None
and Some
. If not (some_is_representable x)
then some x
may raise or return none
.
val none : t
val some_is_representable : value ‑> Core_kernel__.Import.bool
For some representations of immediate options, the encodings of none
and some
overlap. For these representations, some_is_representable value = false
if
value
cannot be represented as an option. For example, Int.Option
uses
min_value
to represent none
. For other representations, some_is_representable
always returns true
.
val is_none : t ‑> Core_kernel__.Import.bool
val is_some : t ‑> Core_kernel__.Import.bool
value_exn (some x) = x
. value_exn none
raises. Unlike Option.value_exn
,
there is no ?message
argument, so that calls to value_exn
that do not raise
also do not have to allocate.
unchecked_value (some x) = x
. unchecked_value none
returns an unspecified
value. unchecked_value t
is intended as an optimization of value_exn t
when
is_some t
is known to be true.
val to_option : t ‑> value Core_kernel__.Import.option
val of_option : value Core_kernel__.Import.option ‑> t
module Optional_syntax : Core_kernel.Optional_syntax.S with type t := t with type value := value
include Core__.Import.Identifiable with type t := t
include sig ... end
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (Core_kernel__.Import.int ‑> 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 hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
val t_of_sexp : Base.Sexp.t ‑> t
val sexp_of_t : t ‑> Base.Sexp.t
include Core_kernel.Identifiable.S_common with type t := t
include sig ... end
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 ‑> Base.Sexp.t
include Core_kernel__.Import.Stringable.S with type t := t
val of_string : string ‑> t
val to_string : t ‑> string
include Core_kernel__.Import.Pretty_printer.S with type t := t
val pp : Base.Formatter.t ‑> t ‑> unit
include Core_kernel.Comparable.S_binable with type t := t
include Core_kernel__.Comparable_intf.S_common
include Base.Comparable.S
include Base__.Comparable_intf.Polymorphic_compare
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)
.
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 Core_kernel.Comparator.S with type t := t
val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator
module Map : Core_kernel.Map.S_binable with type Key.t = t with type Key.comparator_witness = comparator_witness
module Set : Core_kernel.Set.S_binable with type Elt.t = t with type Elt.comparator_witness = comparator_witness
include Core_kernel.Hashable.S_binable with type t := t
include sig ... end
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
val hashable : t Core_kernel.Hashtbl.Hashable.t
module Table : Core_kernel.Hashtbl.S_binable with type key = t
module Hash_set : Core_kernel.Hash_set.S_binable with type elt = t
module Hash_queue : Core_kernel.Hash_queue.S with type Key.t = t
module Stable : sig ... end