include module type of sig ... end
val compare : t ‑> t ‑> Core_kernel__.Import.int
val sexp_of_t : t ‑> Sexplib.Sexp.t
val input_tz_file : zonename:Core_kernel__.Import.string ‑> filename:Core_kernel__.Import.string ‑> t
val likely_machine_zones : Core_kernel__.Import.string Core_kernel__.Import.list Core_kernel__.Import.ref
val of_utc_offset : hours:Core_kernel__.Import.int ‑> t
val utc : t
val abbreviation : t ‑> Time0.t ‑> Core_kernel__.Import.string
val name : t ‑> Core_kernel__.Import.string
val original_filename : t ‑> Core_kernel__.Import.string Core_kernel__.Import.option
val digest : t ‑> Core_kernel__.Import.string Core_kernel__.Import.option
val next_clock_shift : t ‑> after:Time0.t ‑> (Time0.t * Time0.Span.t) Core_kernel__.Import.option
val prev_clock_shift : t ‑> before:Time0.t ‑> (Time0.t * Time0.Span.t) Core_kernel__.Import.option
include Core__.Import.Identifiable.S with type t := t
include sig ... end
val t_of_sexp : Sexplib.Sexp.t ‑> t
val sexp_of_t : t ‑> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
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
include Core_kernel__.Import.Stringable.S with type t := t
val of_string : string ‑> t
val to_string : t ‑> string
include Core_kernel.Comparable.S_binable with type t := t
include Core_kernel__.Comparable_intf.S_common
include Base.Comparable_intf.S
include Base.Comparable_intf.Polymorphic_compare
ascending
is identical to compare
. descending x y = ascending y x
. These are
intended to be mnemonic when used like List.sort ~cmp:ascending
and List.sort
~cmp:descending
, since they cause the list to be sorted in ascending or descending
order, respectively.
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
val comparator : (t, comparator_witness) Base.Comparator.comparator
include Base.Comparable_intf.Validate with type t := 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
module Replace_polymorphic_compare : Core_kernel__.Comparable_intf.Polymorphic_compare with type t := t
include Core_kernel__.Comparable_intf.Map_and_set_binable with type t := t with type comparator_witness := comparator_witness
include Core_kernel.Comparator.S with type t := t
val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator
module Map : Core_kernel__.Core_map.S_binable with type Key.t = t with type Key.comparator_witness = comparator_witness
module Set : Core_kernel__.Core_set.S_binable with type Elt.t = t with type Elt.comparator_witness = comparator_witness
include Core_kernel.Hashable.S_binable with type t := t
val hash : t ‑> Core_kernel__.Import.int
val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
module Table : Core_kernel.Hashable.Hashtbl.S_binable with type key = t
module Hash_set : Core_kernel.Hash_set.S_binable with type elt = t
module Hash_queue : Core_kernel.Hash_queue.S with type Key.t = t
include Core_kernel__.Import.Pretty_printer.S with type t := t
val pp : Caml.Format.formatter ‑> t ‑> unit
val find : string ‑> t option
find name
looks up a t
by its name and returns it. This also accepts some
aliases, including:
val find_exn : string ‑> t
val local : t Core__.Import.Lazy.t
local
is the machine's local timezone, as determined from the TZ
environment variable or the /etc/localtime
file. It is computed from
the state of the process environment and on-disk tzdata database at
some unspecified moment prior to its first use, so its value may be
unpredictable if that state changes during program operation. Arguably,
changing the timezone of a running program is a problematic operation
anyway -- most people write code assuming the clock doesn't suddenly
jump several hours without warning.
Note that any function using this timezone can throw an exception if
the TZ
environment variable is misconfigured or if the appropriate
timezone files can't be found because of the way the box is configured.
We don't sprinkle _exn
all over all the names in this module because
such misconfiguration is quite rare.
val likely_machine_zones : string list Core__.Import.ref
likely_machine_zones
is a list of zone names that will be searched
first when trying to determine the machine zone of a box. Setting this
to a likely set of zones for your application will speed the very first
use of the local timezone.
val of_utc_offset : hours:int ‑> t
of_utc_offset offset
returns a timezone with a static UTC offset (given in
hours).
abbreviation zone t
returns t abbreviation name such as EDT, EST, JST
of given zone
at the time t
. This string conversion is one-way
only, and cannot reliably be turned back into a t
val initialized_zones : unit ‑> (string * t) list
initialized_zones ()
returns a sorted list of time zone names that have
been loaded from disk thus far.
The functions below are lower level and should be used more rarely.
val init : unit ‑> unit
init ()
pre-load all available time zones from disk, this function has no effect if
it is called multiple times. Time zones will otherwise be loaded at need from the
disk on the first call to find/find_exn.
module Stable : sig ... end