# Module Time_ns.Span

    module Span: sig .. end

    type t = private Core_int63.t

`Core_int63.t` is immediate on 64bit boxes and so plays nicely with the GC write barrier. Unfortunately, `private Core_int63.t` is necessary for the compiler to optimize uses.

    val typerep_of_t : t Typerep_lib.Std.Typerep.t

    val typename_of_t : t Typerep_lib.Std.Typename.t

    include Comparable.Infix

    include Comparable.Validate

    include Comparable.With_zero

    include Equal.S

    val nanosecond : t

    val microsecond : t

    val millisecond : t

    val second : t

    val minute : t

    val hour : t

    val day : t

    val of_ns : float -> t

    val of_us : float -> t

    val of_ms : float -> t

    val of_sec : float -> t

    val of_min : float -> t

    val of_hr : float -> t

    val of_day : float -> t

    val to_ns : t -> float

    val to_us : t -> float

    val to_ms : t -> float

    val to_sec : t -> float

    val to_min : t -> float

    val to_hr : t -> float

    val to_day : t -> float

    val of_sec_with_microsecond_precision : float -> t

    val of_int_sec : int -> t

    val to_int_sec : t -> int

    val zero : t

    val min_value : t

The limits of `t` are chosen to allow conversion to and from `float` spans with microsecond precision. This property supports `Core.Std.Timing_wheel_float` in particular. See also `Core.Std.Time`.

    val max_value : t

    val (+) : t -> t -> t

    val (-) : t -> t -> t

    val abs : t -> t

    val neg : t -> t

    val scale : t -> float -> t

    val scale_int : t -> int -> t

    val scale_int63 : t -> Core_int63.t -> t

    val div : t -> t -> Core_int63.t

    val (/) : t -> float -> t

    val (//) : t -> t -> float

    val create : ?sign:Float.Sign.t ->
           ?day:int ->
           ?hr:int ->
           ?min:int ->
           ?sec:int -> ?ms:int -> ?us:int -> ?ns:int -> unit -> t

    module Parts: sig .. end

Similar to `Time.Span.Parts`, but adding `ns`.

    val to_parts : t -> Parts.t

    val of_parts : Parts.t -> t

    include Robustly_comparable

    val to_int63_ns : t -> Core_int63.t

Fast, implemented as the identity function.

Fast, implemented as the identity function.

    val of_int63_ns : Core_int63.t -> t

    val to_int_ns : t -> int

Will raise on 32-bit platforms. Consider `to_int63_ns` instead.

    val of_int_ns : int -> t

    val since_unix_epoch : unit -> t

    module Alternate_sexp: sig .. end

Note that we expose a sexp format that is not the one exposed in `Core`.

    val bin_t : t Bin_prot.Type_class.t

    val bin_read_t : t Bin_prot.Read.reader

    val __bin_read_t__ : (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 compare : t -> t -> int

The limits of `t` are chosen to allow conversion to and from `float` spans with microsecond precision. This property supports `Core.Std.Timing_wheel_float` in particular. See also `Core.Std.Time`.
Similar to `Time.Span.Parts`, but adding `ns`.
Fast, implemented as the identity function.
Fast, implemented as the identity function.
Will raise on 32-bit platforms. Consider `to_int63_ns` instead.
Note that we expose a sexp format that is not the one exposed in `Core`.