`module Time : sig ... end`
`val run_at : Time.t ‑> ('a ‑> unit) ‑> 'a ‑> unit`

`run_at time f a` runs `f a` as soon as possible after `time`. If `time` is in the past, then `run_at` will immediately schedule a job `t` that will run `f a`. In no situation will `run_at` actually call `f` itself. The call to `f` will always be in another job.

`val run_after : Time.Span.t ‑> ('a ‑> unit) ‑> 'a ‑> unit`

`run_after` is like `run_at`, except that one specifies a time span rather than an absolute time.

`val at : Time.t ‑> unit Deferred.t`

`at time` returns a deferred `d` that will become determined as soon as possible after `time`

`val after : Time.Span.t ‑> unit Deferred.t`

`after` is like `at`, except that one specifies a time span rather than an absolute time. If you set up a lot of `after` events at the beginning of your program they will trigger at the same time. Use `Time.Span.randomize` to even them out.

`val with_timeout : Time.Span.t ‑> 'a Deferred.t ‑> [ `Timeout | `Result of 'a ] Deferred.t`

`with_timeout span d` returns a deferred that will become determined after either `span` elapses or `d` is determined, returning either ``Timeout` or ``Result` depending on which one succeeded first. At the time the returned deferred becomes determined, both things may have happened, in which case ``Result` is given preference.

`module Event : sig ... end`

Events provide variants of `run_at` and `run_after` with the ability to abort or reschedule an event that hasn't yet happened. Once an event happens or is aborted, Async doesn't use any space for tracking it.

`val at_varying_intervals : ?⁠stop:unit Deferred.t ‑> (unit ‑> Time.Span.t) ‑> unit Async_kernel__.Async_stream.t`

`at_varying_intervals f ?stop` returns a stream whose next element becomes determined by calling `f ()` and waiting for that amount of time, and then looping to determine subsequent elements. The stream will end after `stop` becomes determined.

`val at_intervals : ?⁠start:Time.t ‑> ?⁠stop:unit Deferred.t ‑> Time.Span.t ‑> unit Async_kernel__.Async_stream.t`

`at_intervals interval ?start ?stop` returns a stream whose elements will become determined at nonnegative integer multiples of `interval` after the `start` time, until `stop` becomes determined:

            start + 0 * interval
            start + 1 * interval
            start + 2 * interval
            start + 3 * interval
            ...

Note that only elements that are strictly in the future ever become determined. In particular, if `start` is not in the future, or `start` is not provided, then there will be no element before the `interval` has passed.

If the interval is too small or the CPU is too loaded, `at_intervals` will skip until the next upcoming multiple of `interval` after `start`.

`val every' : ?⁠start:unit Deferred.t ‑> ?⁠stop:unit Deferred.t ‑> ?⁠continue_on_error:bool ‑> ?⁠finished:unit Async_kernel.Ivar.t ‑> Time.Span.t ‑> (unit ‑> unit Deferred.t) ‑> unit`

`every' ?start ?stop span f` runs `f ()` every `span` amount of time starting when `start` becomes determined and stopping when `stop` becomes determined. `every` waits until the result of `f ()` becomes determined before waiting for the next `span`.

It is guaranteed that if `stop` becomes determined, even during evaluation of `f`, then `f` will not be called again by a subsequent iteration of the loop.

It is an error for `span` to be nonpositive.

With `~continue_on_error:true`, when `f` asynchronously raises, iteration continues. With `~continue_on_error:false`, if `f` asynchronously raises, then iteration only continues when the result of `f` becomes determined.

Exceptions raised by `f` are always sent to monitor in effect when `every'` was called, even with `~continue_on_error:true`.

If `finished` is supplied, `every'` will fill it once all of the following become determined: `start`, `stop`, and the result of the final call to `f`.

`val every : ?⁠start:unit Deferred.t ‑> ?⁠stop:unit Deferred.t ‑> ?⁠continue_on_error:bool ‑> Time.Span.t ‑> (unit ‑> unit) ‑> unit`

`every ?start ?stop span f` is `every' ?start ?stop span (fun () -> f (); return ())`.

`val run_at_intervals' : ?⁠start:Time.t ‑> ?⁠stop:unit Deferred.t ‑> ?⁠continue_on_error:bool ‑> Time.Span.t ‑> (unit ‑> unit Deferred.t) ‑> unit`

`run_at_intervals' ?start ?stop span f` runs `f()` at increments of `start + i * span` for nonnegative integers `i`, until `stop` becomes determined. `run_at_intervals'` waits for the result of `f` to become determined before waiting for the next interval.

Exceptions raised by `f` are always sent to monitor in effect when `run_at_intervals'` was called, even with `~continue_on_error:true`.

`val run_at_intervals : ?⁠start:Time.t ‑> ?⁠stop:unit Deferred.t ‑> ?⁠continue_on_error:bool ‑> Time.Span.t ‑> (unit ‑> unit) ‑> unit`

`run_at_intervals ?start ?stop ?continue_on_error span f` is equivalent to:

            run_at_intervals' ?start ?stop ?continue_on_error span
              (fun () -> f (); return ())