# Module Time_ns_benchmarks.Time_ns_in_this_directory

    module Time_ns_in_this_directory: Time_ns

    type t = Core_kernel.Time_ns.t

    val typerep_of_t : t Typerep_lib.Std.Typerep.t

    val typename_of_t : t Typerep_lib.Std.Typename.t

    module Span: sig .. end

    module Option: sig .. end  with type time := t

    module Ofday: sig .. end  with type time := t

    include Identifiable

    val epoch : t

Unix epoch (1970-01-01 00:00:00 UTC)

    val min_value : t

    val max_value : t

    val now : unit -> t

    val add : t -> Span.t -> t

    val sub : t -> Span.t -> t

    val diff : t -> t -> Span.t

    val abs_diff : t -> t -> Span.t

    val to_span_since_epoch : t -> Span.t

    val of_span_since_epoch : Span.t -> t

    val to_time : t -> Time.t

    val of_time : Time.t -> t

    val to_string_fix_proto : [ `Local | `Utc ] -> t -> string

    val of_string_fix_proto : [ `Local | `Utc ] -> string -> t

    val to_int63_ns_since_epoch : t -> Core_kernel.Std.Int63.t

    val of_int63_ns_since_epoch : Core_kernel.Std.Int63.t -> t

    val to_int_ns_since_epoch : t -> int

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

    val of_int_ns_since_epoch : int -> t

    val next_multiple : ?can_equal_after:bool ->
           base:t ->
           after:t -> interval:Span.t -> unit -> t

See `Core_kernel.Time_ns`

    val of_date_ofday : zone:Zone.t -> Date.t -> Ofday.t -> t

    val to_date : t -> zone:Zone.t -> Date.t

    val occurrence : [ `First_after_or_at | `Last_before_or_at ] ->
           t -> ofday:Ofday.t -> zone:Zone.t -> t

    val pause : Span.t -> unit

`pause span` sleeps for `span` time.

    val interruptible_pause : Span.t -> [ `Ok | `Remaining of Span.t ]

`interruptible_pause span` sleeps for `span` time unless interrupted (e.g. by delivery of a signal), in which case the remaining unslept portion of time is returned.

    val pause_forever : unit -> Core_kernel.Std.never_returns

`pause_forever` sleeps indefinitely.

    module Stable: sig .. end

    val random : unit -> t