`Mtime.Span`

Monotonic time spans.

`type t = span`

See `Mtime.span`

.

`val zero : span`

`zero`

is a span of 0ns.

`val one : span`

`one`

is a span of 1ns.

`val max_span : span`

`max_span`

is 2^{64}-1ns.

`abs_diff span span'`

is the absolute difference between `span`

and `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^{-9}s.

`val us : span`

`us`

is a microsecond duration, 1·10^{-6}s.

`val ms : span`

`ms`

is a millisecond duration, 1·10^{-3}s.

`val s : span`

`s`

is a second duration, 1s.

`val min : span`

`min`

is a minute duration, 60s.

`val hour : span`

`hour`

is an hour duration, 3600s.

`val day : span`

`day`

is a day duration, 86'400s.

`val year : span`

`year`

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

`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 2^{53} (~104 days, the largest exact floating point integer).

`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 2^{53} (~104 days, the largest exact floating point integer) the result is an approximation and will not round trip with `of_float_ns`

.

`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`

.