### Datatypes

`type t`

Type of a time.

`type field = [`

1. `| `Hour`
2. `| `Minute`
3. `| `Second`

`]`

The different fields of a time.

### Second

`type second`

Type of a second.

- since 2.0 (was an integer in previous versions).

`module Second : Second with type t = second`

Second implementation

### Constructors

`val make : int -> int -> second -> t`

`make hour minute second` makes the time hour-minute-second.

`val lmake : ?hour:int -> ?minute:int -> ?second:second -> unit -> t`

Labelled version of `make`. The default value is `0` for each argument.

- since 1.05

`val now : unit -> t`

The current time based on `Time_Zone.current ()`.

`val midnight : unit -> t`

`midnight ()` is midnight (expressed in the current time zone). So, it has always the same behaviour as `make 0 0 0`.

`val midday : unit -> t`

`midday ()` is midday (expressed in the current time zone). So, it has always the same behaviour as `make 12 0 0`.

### Conversions

`val convert : t -> Time_Zone.t -> Time_Zone.t -> t`

`convert t t1 t2` converts the time `t` expressed in the time zone `t1` to the same time expressed in the time zone `t2`. @example `convert (make 20 0 0) (Time_Zone.GMT_Plus 2) (Time_Zone.GMT_Plus 4)` returns the time 22-0-0.

`val from_gmt : t -> t`

`from_gmt t` is equivalent to `convert t Time_Zone.GMT (Time_Zone.current ())`.

`val to_gmt : t -> t`

`to_gmt t` is equivalent to `convert t (Time_Zone.current ()) Time_Zone.GMT`.

`val normalize : t -> t * int`

`normalize t` returns `t` such that `hour t` belongs to `[0; 24[`. The second component of the result is the number of days needed by the modification. @example `normalize (make 22 0 0)` returns the time 22-0-0 and 0, `normalize (make 73 0 0)` returns the time 1-0-0 and 3 and `normalize (make (-73) 0 0)` returns the time 23-0-0 and (-4).

### Getters

`val hour : t -> int`

Hour. @example `hour (make 20 0 0)` returns 20.

`val minute : t -> int`

Minute. @example `minute (make 20 10 0)` returns 10.

`val second : t -> second`

Second. @example `second (make 20 10 5)` returns 5.

`val to_seconds : t -> second`

Number of seconds of a time. @example `to_seconds (make 1 2 3)` returns `3600 + 120 + 3 = 3723`.

`val to_minutes : t -> float`

Number of minutes of a time. The resulting fractional part represents seconds. @example `to_minutes (make 1 2 3)` returns `60+2+0.05 = 62.05`.

`val to_hours : t -> float`

Number of hours of a time. The resulting fractional part represents minutes and seconds. @example `to_hours (make 1 3 0)` returns `1 + 0.05 = 1.05`.

### Times are comparable

`val equal : t -> t -> bool`

Equality function between two times.

- see Utils.Comparable.html#VALequal

  Utils.Comparable.equal.

- since 1.09.0

`val compare : t -> t -> int`

Comparison function between two times.

- see Utils.Comparable.html#VALcompare

  Utils.Comparable.compare.

`val hash : t -> int`

Hash function for times.

- see Utils.Comparable.html#VALhash

  Utils.Comparable.hash.

- since 2.0

### Boolean operations on times

`val is_pm : t -> bool`

Return `true` is the time is before midday in the current time zone; `false` otherwise. @example both `is_pm (make 10 0 0)` and `is_pm (make 34 0 0)` return `true`.

`val is_am : t -> bool`

Return `true` is the time is after midday in the current time zone; `false` otherwise. @example both `is_am (make 20 0 0)` and `is_am (make 44 0 0)` return `true`.

### Coercions

`val from_seconds : second -> t`

Inverse of `to_seconds`.

`val from_minutes : float -> t`

Inverse of `to_minutes`.

`val from_hours : float -> t`

Inverse of `to_hours`.

### Period

`module Period : sig ... end`

A period is the number of seconds between two times.

### Arithmetic operations on times and periods

`val add : t -> 'a Period.period -> t`

`app t p` returns `t + p`. @example `add (make 20 0 0) (Period.minute 70)` returns the time 21:10:0.

`val sub : t -> t -> 'a Period.period`

`sub t1 t2` returns the period between `t1` and `t2`.

`val rem : t -> 'a Period.period -> t`

`rem t p` is equivalent to `add t (Period.opp p)`.

`val next : t -> field -> t`

`next t f` returns the time corresponding to the next specified field. @example `next (make 20 3 31) `Minute` returns the time 20:04:31. (i.e. one minute later).

`val prev : t -> field -> t`

`prev t f` returns the time corresponding to the previous specified field. @example `prev (make 20 3 31) `Second` returns the time 20:03:30 (i.e. one second ago).