# Module `Mtime.Span`

Monotonic time spans

## Time spans

`type t`

The type for non-negative monotonic time spans.

They represent the difference between two monotonic clock readings with nanosecond precision (1e-9s) and can measure up to approximatevely 584 Julian year spans before silently rolling over (unlikely since this is in a single program run).

`val zero : t`

`zero` is a span of 0ns.

`val one : t`

`one` is a span of 1ns.

`val max_span : t`

`max_span` is a span of `2^64-1`ns.

`val add : t -> t -> t`

`add s0 s1` is `s0` + `s1`. Warning. Rolls over on overflow.

`val abs_diff : t -> t -> t`

`abs_diff s0 s1` is the absolute difference between `s0` and `s1`.

## Predicates and comparisons

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

`equal s0 s1` is `s0 = s1`.

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

`compare s0 s1` orders span by increasing duration.

`val is_shorter : t -> than:t -> bool`

`is_shorter span ~than` is `true` iff `span` lasts less than `than`.

`val is_longer : t -> than:t -> bool`

`is_longer span ~than` is `true` iff `span` lasts more than `than`.

## Durations

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

`n * dur` is `n` times duration `n`. Does not check for overflow or that `n` is positive.

`val ns : t`

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

`val us : t`

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

`val ms : t`

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

`val s : t`

`s` is a second duration, 1s.

`val min : t`

`min` is a minute duration, 60s.

`val hour : t`

`hour` is an hour duration, 3600s.

`val day : t`

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

`val year : t`

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

## Conversions

`val to_uint64_ns : t -> int64`

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

`val of_uint64_ns : int64 -> t`

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

`val of_float_ns : float -> t 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).

`val to_float_ns : t -> 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`.

## Formatting

`val pp : t Fmt.t`

`pp` formats with `Fmt.uint64_ns_span`.

`val pp_ns : t Fmt.t`

`pp_ns ppf s` prints `s` as an unsigned 64-bit integer nanosecond span.