Module Core__Time_ns_intf.Span.Option

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 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 : value ‑> 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
val value : t ‑> default:value ‑> value

value (some x) ~default = x and value none ~default = default.

val value_exn : t ‑> value

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.

val unchecked_value : t ‑> value

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
type t
include sig ... end
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
type 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
type t
val of_string : string ‑> t
val to_string : t ‑> string
include Core_kernel__.Import.Pretty_printer.S with type t := t
type 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
include Base.Comparisons.Infix
type 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

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.

val min : t ‑> t ‑> t
val max : t ‑> t ‑> t
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
type t
type comparator_witness
include Base__.Comparable_intf.Validate with type t := t
type 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
include Core_kernel.Hashable.S_binable with type t := t
type t
include sig ... end
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
module Stable : sig ... end