package core_unix

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type
include module type of struct include Time.Ofday end
type t = private Time.underlying
include Bin_prot.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions 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

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

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
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 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
include Base.Comparisons.S with type t := t
include Base.Comparisons.Infix 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

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 comparator_witness = Time.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.Ofday.Replace_polymorphic_compare
module Map = Time.Ofday.Map
module Set = Time.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 : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
val hashable : t Base.Hashable.t
module Table = Time.Ofday.Table
module Hash_set = Time.Ofday.Hash_set
module Hash_queue = Time.Ofday.Hash_queue
include Base.Pretty_printer.S with type t := t
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.

include Core.Interfaces.Stringable with type t := t
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 to_parts : t -> Time.Span.Parts.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.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.Span.t -> t
val of_span_since_start_of_day : 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.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.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.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.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.

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

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.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 : sig ... end
val now : zone:Zone.t -> t
OCaml

Innovation. Community. Security.