package async_unix

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type
include module type of struct include Time_float_unix.Time.Ofday end
include Bin_prot.Binable.S with type t := t
val bin_size_t : t Bin_prot__.Size.sizer
val bin_write_t : t Bin_prot__.Write.writer
val bin_read_t : t Bin_prot__.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot__.Read.reader
val bin_shape_t : Bin_prot__.Shape.t
val bin_writer_t : t Bin_prot__.Type_class.writer
val bin_reader_t : t Bin_prot__.Type_class.reader
val bin_t : t Bin_prot__.Type_class.t
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0__.Sexp.t -> t
val sexp_of_t : t -> Sexplib0__.Sexp.t
val t_sexp_grammar : t Sexplib0.Sexp_grammar.t
include Typerep_lib.Typerepable.S with type t := t
val typerep_of_t : t Typerep_lib.Std_internal.Typerep.t
val typename_of_t : t Typerep_lib.Typename.t
include Core.Interfaces.Comparable_binable with type t := t
include Base.Comparable.S with type t := 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
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness = Time_float_unix.Ofday.comparator_witness
val validate_lbound : min:t Core.Maybe_bound.t -> t Validate.check
val validate_ubound : max:t Core.Maybe_bound.t -> t Validate.check
val validate_bound : min:t Core.Maybe_bound.t -> max:t Core.Maybe_bound.t -> t Validate.check
module Replace_polymorphic_compare = Time_float_unix.Ofday.Replace_polymorphic_compare
module Map = Time_float_unix.Ofday.Map
module Set = Time_float_unix.Ofday.Set
include Core.Interfaces.Hashable_binable with type t := t
include Ppx_hash_lib.Hashable.S with type t := t
val hash_fold_t : t Base__Ppx_hash_lib.hash_fold
val hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core__.Hashtbl.Hashable.t
module Table = Time_float_unix.Ofday.Table
module Hash_set = Time_float_unix.Ofday.Hash_set
module Hash_queue = Time_float_unix.Ofday.Hash_queue
val pp : Base__.Formatter.t -> t -> unit
include Core.Interfaces.Robustly_comparable with type t := 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 robustly_compare : t -> t -> int
include Core.Quickcheck.S_range with type t := t
include Core.Quickcheck_intf.S with type t := t
val quickcheck_generator : t Base_quickcheck.Generator.t
val quickcheck_observer : t Base_quickcheck.Observer.t
val quickcheck_shrinker : t Base_quickcheck.Shrinker.t
val gen_incl : t -> t -> t Base_quickcheck.Generator.t

gen_incl lower_bound upper_bound produces values between lower_bound and upper_bound, inclusive. It uses an ad hoc distribution that stresses boundary conditions more often than a uniform distribution, while still able to produce any value in the range. Raises if lower_bound > upper_bound.

val gen_uniform_incl : t -> t -> t Base_quickcheck.Generator.t

gen_uniform_incl lower_bound upper_bound produces a generator for values uniformly distributed between lower_bound and upper_bound, inclusive. Raises if lower_bound > upper_bound.

of_string supports and correctly interprets 12h strings with the following suffixes:

      "A", "AM", "A.M.", "A.M"
      "P", "PM", "P.M.", "P.M"

as well as the lowercase and space-prefixed versions of these suffixes.

of_string also fully supports 24h wall-clock times.

to_string only produces the 24h format.

val of_string : string -> t
val to_string : t -> string
val create : ?hr:Base.Int.t -> ?min:Base.Int.t -> ?sec:Base.Int.t -> ?ms:Base.Int.t -> ?us:Base.Int.t -> ?ns:Base.Int.t -> Base.Unit.t -> t
val start_of_day : t

Smallest valid ofday.

val start_of_next_day : t

Largest representable ofday; see notes above on how start_of_next_day behaves differently from other ofday values.

val approximate_end_of_day : t

A time very close to the end of a day. Not necessarily the largest representable value before start_of_next_day, but as close as possible such that using this ofday with Time.of_date_ofday and Time.to_date should round-trip to the same date. With floating-point representations of time, this may not be possible for dates extremely far from epoch.

The clock-face time represented by approximate_end_of_day may vary with different time and ofday representations, depending on their precision.

val to_span_since_start_of_day : t -> Time_float_unix.Time.Span.t

Note that these names are only really accurate on days without DST transitions. When clocks move forward or back, of_span_since_start_of_day_exn s will not necessarily occur s after that day's midnight.

val of_span_since_start_of_day_exn : Time_float_unix.Time.Span.t -> t
val of_span_since_start_of_day : Time_float_unix.Time.Span.t -> t
  • deprecated [since 2018-04] use [of_span_since_start_of_day_exn] instead
val span_since_start_of_day_is_valid : Time_float_unix.Time.Span.t -> Base.Bool.t

Reports whether a span represents a valid time since the start of the day, i.e. whether of_span_since_start_of_day_exn span would succeed.

val of_span_since_start_of_day_unchecked : Time_float_unix.Time.Span.t -> t

of_span_since_start_of_day_unchecked does not validate that the Span represents a valid Ofday.

Behavior of other Ofday accessors is unspecified, but still safe (e.g., won't segfault), if the input does not satisfy span_since_start_of_day_is_valid.

val add : t -> Time_float_unix.Time.Span.t -> t Base.Option.t

add t s shifts the time of day t by the span s. It returns None if the result is not in the same 24-hour day.

val sub : t -> Time_float_unix.Time.Span.t -> t Base.Option.t
val next : t -> t Base.Option.t

next t return the next t (next t > t) or None if t = end of day.

val prev : t -> t Base.Option.t

prev t return the previous t (prev t < t) or None if t = start of day.

diff t1 t2 returns the difference in time between two ofdays, as if they occurred on the same 24-hour day.

val small_diff : t -> t -> Time_float_unix.Time.Span.t

Returns the time-span separating the two of-days, ignoring the hour information, and assuming that the of-days represent times that are within a half-hour of each other. This is useful for comparing two ofdays in unknown time-zones.

val to_string_trimmed : t -> Base.String.t

Trailing groups of zeroes are trimmed such that the output is printed in terms of the smallest non-zero units among nanoseconds, microseconds, milliseconds, or seconds; or minutes if all of the above are zero.

val to_sec_string : t -> Base.String.t

HH:MM:SS, without any subsecond components. Seconds appear even if they are zero.

val of_string_iso8601_extended : ?pos:Base.Int.t -> ?len:Base.Int.t -> Base.String.t -> t

24-hour times according to the ISO 8601 standard. This function can raise.

val to_millisecond_string : t -> Base.String.t

with milliseconds

val to_millisec_string : t -> Base.String.t
  • deprecated [since 2018-04] use [to_millisecond_string] instead
val arg_type : t Core.Command.Arg_type.t
module Zoned = Time_float_unix.Ofday.Zoned
val now : zone:Zone.t -> t
  • deprecated [since 2019-05] Use [Time_source]
OCaml

Innovation. Community. Security.