Zero magnitude duration (instant)

Return true if the time duration is zero

Duration constructor

Random duration between the provided min and max durations.

This can be used to seed a schedule in parallel. Providing another method of de-correlation.

For example, this is a linear schedule that,

• starts with a seed duration between 10 and 50 milliseconds

• includes a 10% jitter, added and removed in sequence from each duration

• recurring 5 times

  Schedule.linear(Duration.Random(10ms, 50ms)) | Schedule.decorrelate() | Schedule.recurs(5)

Three runs result in,

(25ms, 23ms, 50ms, 47ms, 72ms)
(13ms, 11ms, 25ms, 23ms, 40ms)
(28ms, 25ms, 56ms, 53ms, 87ms)

Identity or no-op schedule result transformer

Schedule that runs forever

Schedule that never runs

Schedule that runs once

A schedule transformer that will enforce the first retry has no delay

Repeats the schedule forever

Schedule constructor that recurs for the specified durations

Schedule constructor that recurs for the specified durations

Schedule constructor that recurs for the specified durations

Schedule constructor that recurs for the specified durations

Schedule constructor that recurs for the specified durations

Schedule constructor that recurs for the specified durations

ScheduleTransformer constructor which provides mapping capabilities for Schedule instances

Schedule transformer that limits the schedule to run the specified number of times

Schedule that recurs continuously with the given spacing

Schedule that recurs continuously using a linear backoff

Schedule that recurs continuously using a exponential backoff

Schedule that recurs continuously using a fibonacci based backoff

Schedule that runs for a given duration

Schedule that recurs on a fixed interval.

If the action run between updates takes longer than the interval, then the action will be run immediately, but re-runs will not "pile up".

|-----interval-----|-----interval-----|-----interval-----|
|---------action--------||action|-----|action|-----------|

A schedule that divides the timeline into interval-long windows, and sleeps until the nearest window boundary every time it recurs.

For example, Windowed(10 * seconds) would produce a schedule as follows:

     10s        10s        10s       10s
|----------|----------|----------|----------|
|action------|sleep---|act|-sleep|action----|

Cron-like schedule that recurs every specified second of each minute

Cron-like schedule that recurs every specified minute of each hour

Cron-like schedule that recurs every specified hour of each day

Cron-like schedule that recurs every specified day of each week

A schedule transformer that limits the returned delays to max delay

Limits the schedule to the max cumulative delay

A schedule transformer that adds a random jitter to any returned delay

A schedule transformer that adds a random jitter to any returned delay

Transforms the schedule by de-correlating each of the durations both up and down in a jittered way

Given a linear schedule starting at 100. (100, 200, 300...) Adding de-correlation to it might produce a result like this, (103.2342, 97.123, 202.3213, 197.321...) The overall schedule runs twice as long but should be less correlated when used in parallel.

Resets the schedule after a provided cumulative max duration

Repeats the schedule n number of times

NOTE: This repeats the entire schedule! Use Schedule.recurs(n) for 'number of attempts'.

Intersperse the provided duration(s) between each duration in the schedule

Intersperse the provided duration(s) between each duration in the schedule

Take all but the first duration from the schedule

Prepend a zero duration in-front of the rest of the scheduled durations

Realise the underlying time-series of durations

Intersection of two schedules. As long as they are both running it returns the max duration

Union of two schedules. As long as any are running it returns the min duration of both or a or b

Interleave two schedules together

Append two schedules together

Take amount durations from the Schedule

Skip amount durations from the Schedule

Prepend a duration in-front of the rest of the scheduled durations

Functor map operation for Schedule

Functor map operation for Schedule

Filter operation for Schedule

Filter operation for Schedule

Functor map operation for Schedule

Functor map operation for Schedule

Monad bind operation for Schedule

Monad bind operation for Schedule

Monad bind and project operation for Schedule

Converts a Seq of positive durations to a schedule

Converts a Arr of positive durations to a schedule

Converts a Lst of positive durations to a schedule

Converts a Set of positive durations to a schedule

Converts a HashSet of positive durations to a schedule

Prepend a duration to the schedule

Intersection of two schedules. As long as they are both running it returns the max duration

Union of two schedules. As long as any are running it returns the min duration of both or a or b

Interleave two schedules together

Append two schedules together

Take amount durations from the Schedule

Skip amount durations from the Schedule

Take all but the first duration from the schedule

Functor map operation for Schedule

Filter operation for Schedule

Monad bind operation for Schedule

Apply a schedule to the transformer

Compose the two transformers into one