# Module `Mtime.Span`

Monotonic time spans.

## Monotonic time spans

`type t = span`
`val zero : span`

`zero` is a span of 0ns.

`val one : span`

`one` is a span of 1ns.

`val min_span : span`

`min_span` is `zero`.

`val max_span : span`

`max_span` is 264-1ns.

## Predicates

`val equal : span -> span -> bool`

`equal span span'` is `true` iff `span` and `span'` are equal.

`val compare : span -> span -> int`

`compare span span'` orders spans by increasing duration.

## Arithmetic

`val add : span -> span -> span`

`add span span'` is `span + span'`.

Warning. Rolls over on overflow.

`val abs_diff : span -> span -> span`

`abs_diff span span'` is the absolute difference between `span` and `span'`.

## Durations

`val (*) : int -> span -> span`

`n * dur` is `n` times duration `dur`.

Warning. Does not check for overflow or that `n` is positive.

`val ns : span`

`ns` is a nanosecond duration, 1·10-9s.

• since 1.4.0
`val us : span`

`us` is a microsecond duration, 1·10-6s.

• since 1.4.0
`val ms : span`

`ms` is a millisecond duration, 1·10-3s.

• since 1.4.0
`val s : span`

`s` is a second duration, 1s.

• since 1.4.0
`val min : span`

`min` is a minute duration, 60s.

• since 1.4.0
`val hour : span`

`hour` is an hour duration, 3600s.

• since 1.4.0
`val day : span`

`day` is a day duration, 86'400s.

• since 1.4.0
`val year : span`

`year` is a Julian year duration (365.25 days), 31'557'600s.

## Converting

`val to_uint64_ns : span -> int64`

`to_uint64_ns span` is `span` as an unsigned 64-bit integer nanosecond span.

`val of_uint64_ns : int64 -> span`

`of_uint64_ns u` is the unsigned 64-bit integer nanosecond span `u` as a span.

`val of_float_ns : float -> span option`

`of_float_ns f` is the positive floating point nanosecond span `f` as a span. This is `None` if `f` is negative, non finite, or larger or equal than 253 (~104 days, the largest exact floating point integer).

• since 2.0.0
`val to_float_ns : span -> float`

`to_float_ns s` is `span` as a nanosecond floating point span. Note that if `s` is larger than 253 (~104 days, the largest exact floating point integer) the result is an approximation and will not round trip with `of_float_ns`.

• since 2.0.0

## Formatters

`val pp : Stdlib.Format.formatter -> span -> unit`

`pp` formats spans according to their magnitude using SI prefixes on seconds and accepted non-SI units. Years are counted in Julian years (365.25 SI-accepted days) as defined by the International Astronomical Union.

Rounds towards positive infinity, i.e. over approximates, no duration is formatted shorter than it is.

The output is UTF-8 encoded, it uses U+03BC for `µs` (10-6`s`).

`val dump : Stdlib.Format.formatter -> t -> unit`

`dump ppf span` formats an unspecified raw representation of `span` on `ppf`.