Combining schedules

Decides, after each execution of a flow, whether to run it again and how long to wait first. A schedule value holds no state, so the same value can drive any number of independent runs.

An environment containing only a clock, for timed flows with no other services.

An abbreviation for the CLI type . Basic Types

Builds and combines schedules that decide whether, and after what delay, a flow runs again. Drive a schedule with Flow.retry (after typed failures), Flow.repeat (after successes), or FlowStream.fromSchedule (as a stream of its outputs). A schedule holds no state, so one value can drive any number of independent runs.

Creates a schedule that recurs with exponential backoff. The initial delay for the first retry. A schedule that recurs indefinitely, doubling the delay each time (baseDelay * 2^attempt) and capping at instead of overflowing. Thrown when is negative. let backoff () = Schedule.exponential (TimeSpan.FromMilliseconds 100.0) // Delays: 100ms, 200ms, 400ms, 800ms...

Represents a time interval.

Returns a that represents a specified number of milliseconds. A number of milliseconds. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Continues while either schedule continues, waiting for the shorter of their delays. Both schedules are consulted at every decision. The output pairs their outputs; a side that has stopped contributes None, and the delay is then the continuing side's delay. The combined schedule stops when both have stopped. The schedule combined with the piped-in schedule; its output is the second element. The piped-in schedule; its output is the first element. // Exponential back-off capped at 30 s, retrying forever Schedule.exponential (TimeSpan.FromMilliseconds 200.0) |> Schedule.union (Schedule.spaced (TimeSpan.FromSeconds 30.0))

Creates a schedule that recurs with a fixed delay between attempts. The fixed time span to wait between each attempt. A schedule that recurs indefinitely with the specified fixed delay, emitting the current attempt count. Thrown when is negative. let everySecond () = Schedule.spaced (TimeSpan.FromSeconds 1.0)

Returns a that represents a specified number of seconds, where the specification is accurate to the nearest millisecond. A number of seconds, accurate to the nearest millisecond. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Builds and combines schedules that decide whether, and after what delay, a flow runs again. Drive a schedule with Flow.retry (after typed failures), Flow.repeat (after successes), or FlowStream.fromSchedule (as a stream of its outputs). A schedule holds no state, so one value can drive any number of independent runs.

Creates a schedule that recurs with exponential backoff. The initial delay for the first retry. A schedule that recurs indefinitely, doubling the delay each time (baseDelay * 2^attempt) and capping at instead of overflowing. Thrown when is negative. let backoff () = Schedule.exponential (TimeSpan.FromMilliseconds 100.0) // Delays: 100ms, 200ms, 400ms, 800ms...

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Continues while either schedule continues, waiting for the shorter of their delays. Both schedules are consulted at every decision. The output pairs their outputs; a side that has stopped contributes None, and the delay is then the continuing side's delay. The combined schedule stops when both have stopped. The schedule combined with the piped-in schedule; its output is the second element. The piped-in schedule; its output is the first element. // Exponential back-off capped at 30 s, retrying forever Schedule.exponential (TimeSpan.FromMilliseconds 200.0) |> Schedule.union (Schedule.spaced (TimeSpan.FromSeconds 30.0))

Creates a schedule that recurs with a fixed delay between attempts. The fixed time span to wait between each attempt. A schedule that recurs indefinitely with the specified fixed delay, emitting the current attempt count. Thrown when is negative. let everySecond () = Schedule.spaced (TimeSpan.FromSeconds 1.0)

The representation of "Value of type 'T" The input value. An option representing the value.

Decides, after each execution of a flow, whether to run it again and how long to wait first. A schedule value holds no state, so the same value can drive any number of independent runs.

An environment containing only a clock, for timed flows with no other services.

An abbreviation for the CLI type . Basic Types

Builds and combines schedules that decide whether, and after what delay, a flow runs again. Drive a schedule with Flow.retry (after typed failures), Flow.repeat (after successes), or FlowStream.fromSchedule (as a stream of its outputs). A schedule holds no state, so one value can drive any number of independent runs.

Creates a schedule that recurs a fixed number of times. counts the schedule's own decisions, not the total number of flow executions: Flow.retry and Flow.repeat always run the source flow once before consulting the schedule at all, so recurs 3 means 3 additional retries/repeats on top of that one free attempt: 4 executions in total, not 3. A Schedule value carries no state of its own (the attempt count lives in the retry/repeat call), so the same schedule value is safe to reuse across independent runs. The maximum number of additional times to recur, on top of the source flow's one free initial attempt. A schedule that recurs up to times, emitting the current attempt count (0 to n-1). let retryThreeTimes () = Schedule.recurs 3 // Flow.retry runs the source flow once for free, then consults the schedule at // attempts 0, 1, 2 (three retries) before giving up: 4 executions in total.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Continues while both schedules continue, waiting for the longer of their delays. The schedule combined with the piped-in schedule; its output is the second element. The piped-in schedule; its output is the first element. // At most 10 retries, with exponential back-off Schedule.recurs 10 |> Schedule.intersect (Schedule.exponential (TimeSpan.FromMilliseconds 200.0))

Creates a schedule that recurs with exponential backoff. The initial delay for the first retry. A schedule that recurs indefinitely, doubling the delay each time (baseDelay * 2^attempt) and capping at instead of overflowing. Thrown when is negative. let backoff () = Schedule.exponential (TimeSpan.FromMilliseconds 100.0) // Delays: 100ms, 200ms, 400ms, 800ms...

Represents a time interval.

Returns a that represents a specified number of milliseconds. A number of milliseconds. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Builds and combines schedules that decide whether, and after what delay, a flow runs again. Drive a schedule with Flow.retry (after typed failures), Flow.repeat (after successes), or FlowStream.fromSchedule (as a stream of its outputs). A schedule holds no state, so one value can drive any number of independent runs.

Creates a schedule that recurs a fixed number of times. counts the schedule's own decisions, not the total number of flow executions: Flow.retry and Flow.repeat always run the source flow once before consulting the schedule at all, so recurs 3 means 3 additional retries/repeats on top of that one free attempt: 4 executions in total, not 3. A Schedule value carries no state of its own (the attempt count lives in the retry/repeat call), so the same schedule value is safe to reuse across independent runs. The maximum number of additional times to recur, on top of the source flow's one free initial attempt. A schedule that recurs up to times, emitting the current attempt count (0 to n-1). let retryThreeTimes () = Schedule.recurs 3 // Flow.retry runs the source flow once for free, then consults the schedule at // attempts 0, 1, 2 (three retries) before giving up: 4 executions in total.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Continues while both schedules continue, waiting for the longer of their delays. The schedule combined with the piped-in schedule; its output is the second element. The piped-in schedule; its output is the first element. // At most 10 retries, with exponential back-off Schedule.recurs 10 |> Schedule.intersect (Schedule.exponential (TimeSpan.FromMilliseconds 200.0))

Creates a schedule that recurs with exponential backoff. The initial delay for the first retry. A schedule that recurs indefinitely, doubling the delay each time (baseDelay * 2^attempt) and capping at instead of overflowing. Thrown when is negative. let backoff () = Schedule.exponential (TimeSpan.FromMilliseconds 100.0) // Delays: 100ms, 200ms, 400ms, 800ms...

Represents a time interval.

Returns a that represents a specified time, where the specification is in units of ticks. A number of ticks that represent a time. An object that represents .

Decides, after each execution of a flow, whether to run it again and how long to wait first. A schedule value holds no state, so the same value can drive any number of independent runs.

An environment containing only a clock, for timed flows with no other services.

An abbreviation for the CLI type . Basic Types

Builds and combines schedules that decide whether, and after what delay, a flow runs again. Drive a schedule with Flow.retry (after typed failures), Flow.repeat (after successes), or FlowStream.fromSchedule (as a stream of its outputs). A schedule holds no state, so one value can drive any number of independent runs.

Creates a schedule that recurs with a fixed delay between attempts. The fixed time span to wait between each attempt. A schedule that recurs indefinitely with the specified fixed delay, emitting the current attempt count. Thrown when is negative. let everySecond () = Schedule.spaced (TimeSpan.FromSeconds 1.0)

Represents a time interval.

Returns a that represents a specified number of milliseconds. A number of milliseconds. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Stops a schedule after at most recurrences, keeping its output and delays. Like recurs, counts recurrences after the first run, so recursAtMost 3 with Flow.retry allows 4 executions in total. The maximum number of recurrences. The schedule to cap. Schedule.exponential (TimeSpan.FromMilliseconds 100.0) |> Schedule.recursAtMost 5

Runs until it stops, then continues with . starts counting from zero when it takes over, so recurs and exponential behave as if it were the only schedule. The output says which phase decided. The schedule that takes over once the first stops. The schedule that runs first. // Three quick retries, then slower ones Schedule.spaced (TimeSpan.FromMilliseconds 100.0) |> Schedule.recursAtMost 3 |> Schedule.andThen (Schedule.exponential (TimeSpan.FromSeconds 1.0) |> Schedule.recursAtMost 5)

Creates a schedule that recurs with exponential backoff. The initial delay for the first retry. A schedule that recurs indefinitely, doubling the delay each time (baseDelay * 2^attempt) and capping at instead of overflowing. Thrown when is negative. let backoff () = Schedule.exponential (TimeSpan.FromMilliseconds 100.0) // Delays: 100ms, 200ms, 400ms, 800ms...

Returns a that represents a specified number of seconds, where the specification is accurate to the nearest millisecond. A number of seconds, accurate to the nearest millisecond. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Builds and combines schedules that decide whether, and after what delay, a flow runs again. Drive a schedule with Flow.retry (after typed failures), Flow.repeat (after successes), or FlowStream.fromSchedule (as a stream of its outputs). A schedule holds no state, so one value can drive any number of independent runs.

Creates a schedule that recurs with a fixed delay between attempts. The fixed time span to wait between each attempt. A schedule that recurs indefinitely with the specified fixed delay, emitting the current attempt count. Thrown when is negative. let everySecond () = Schedule.spaced (TimeSpan.FromSeconds 1.0)

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Stops a schedule after at most recurrences, keeping its output and delays. Like recurs, counts recurrences after the first run, so recursAtMost 3 with Flow.retry allows 4 executions in total. The maximum number of recurrences. The schedule to cap. Schedule.exponential (TimeSpan.FromMilliseconds 100.0) |> Schedule.recursAtMost 5

Runs until it stops, then continues with . starts counting from zero when it takes over, so recurs and exponential behave as if it were the only schedule. The output says which phase decided. The schedule that takes over once the first stops. The schedule that runs first. // Three quick retries, then slower ones Schedule.spaced (TimeSpan.FromMilliseconds 100.0) |> Schedule.recursAtMost 3 |> Schedule.andThen (Schedule.exponential (TimeSpan.FromSeconds 1.0) |> Schedule.recursAtMost 5)

Creates a schedule that recurs with exponential backoff. The initial delay for the first retry. A schedule that recurs indefinitely, doubling the delay each time (baseDelay * 2^attempt) and capping at instead of overflowing. Thrown when is negative. let backoff () = Schedule.exponential (TimeSpan.FromMilliseconds 100.0) // Delays: 100ms, 200ms, 400ms, 800ms...

Decides, after each execution of a flow, whether to run it again and how long to wait first. A schedule value holds no state, so the same value can drive any number of independent runs.

An environment containing only a clock, for timed flows with no other services.

An abbreviation for the CLI type . Basic Types

Builds and combines schedules that decide whether, and after what delay, a flow runs again. Drive a schedule with Flow.retry (after typed failures), Flow.repeat (after successes), or FlowStream.fromSchedule (as a stream of its outputs). A schedule holds no state, so one value can drive any number of independent runs.

Creates a schedule that recurs with exponential backoff. The initial delay for the first retry. A schedule that recurs indefinitely, doubling the delay each time (baseDelay * 2^attempt) and capping at instead of overflowing. Thrown when is negative. let backoff () = Schedule.exponential (TimeSpan.FromMilliseconds 100.0) // Delays: 100ms, 200ms, 400ms, 800ms...

Represents a time interval.

Returns a that represents a specified number of milliseconds. A number of milliseconds. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Stops a schedule once has passed since the first run began. Time is measured with the runtime's clock. The schedule continues while the elapsed time is below the budget, so a retry that is already scheduled still runs even if its delay ends a little past the budget; a run in progress is never cut short. Use Flow.timeout to bound a single run, and recursAtMost to cap the number of recurrences instead. The total time the schedule may keep recurring. The schedule to bound. // Retry with backoff, but give up after two minutes in total Schedule.exponential (TimeSpan.FromMilliseconds 200.0) |> Schedule.upTo (TimeSpan.FromMinutes 2.0)

Returns a that represents a specified number of minutes, where the specification is accurate to the nearest millisecond. A number of minutes, accurate to the nearest millisecond. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Builds and combines schedules that decide whether, and after what delay, a flow runs again. Drive a schedule with Flow.retry (after typed failures), Flow.repeat (after successes), or FlowStream.fromSchedule (as a stream of its outputs). A schedule holds no state, so one value can drive any number of independent runs.

Creates a schedule that recurs with exponential backoff. The initial delay for the first retry. A schedule that recurs indefinitely, doubling the delay each time (baseDelay * 2^attempt) and capping at instead of overflowing. Thrown when is negative. let backoff () = Schedule.exponential (TimeSpan.FromMilliseconds 100.0) // Delays: 100ms, 200ms, 400ms, 800ms...

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Stops a schedule once has passed since the first run began. Time is measured with the runtime's clock. The schedule continues while the elapsed time is below the budget, so a retry that is already scheduled still runs even if its delay ends a little past the budget; a run in progress is never cut short. Use Flow.timeout to bound a single run, and recursAtMost to cap the number of recurrences instead. The total time the schedule may keep recurring. The schedule to bound. // Retry with backoff, but give up after two minutes in total Schedule.exponential (TimeSpan.FromMilliseconds 200.0) |> Schedule.upTo (TimeSpan.FromMinutes 2.0)

Structural greater-than-or-equal The first parameter. The second parameter. The result of the comparison. 5 >= 1 // Evaluates to true 5 >= 5 // Evaluates to true [1; 5] >= [1; 6] // Evaluates to false

Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand The first value. The second value. The result of the operation.

Structural less-than-or-equal comparison The first parameter. The second parameter. The result of the comparison. 5 <= 1 // Evaluates to false 5 <= 5 // Evaluates to true [1; 5] <= [1; 6] // Evaluates to true

Decides, after each execution of a flow, whether to run it again and how long to wait first. A schedule value holds no state, so the same value can drive any number of independent runs.

An environment containing only a clock, for timed flows with no other services.

An abbreviation for the CLI type . Basic Types

Builds and combines schedules that decide whether, and after what delay, a flow runs again. Drive a schedule with Flow.retry (after typed failures), Flow.repeat (after successes), or FlowStream.fromSchedule (as a stream of its outputs). A schedule holds no state, so one value can drive any number of independent runs.

Creates a schedule that recurs with exponential backoff. The initial delay for the first retry. A schedule that recurs indefinitely, doubling the delay each time (baseDelay * 2^attempt) and capping at instead of overflowing. Thrown when is negative. let backoff () = Schedule.exponential (TimeSpan.FromMilliseconds 100.0) // Delays: 100ms, 200ms, 400ms, 800ms...

Represents a time interval.

Returns a that represents a specified number of milliseconds. A number of milliseconds. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Continues only while the schedule's output satisfies a predicate. Where whileInput looks at the error or value being retried, this looks at what the schedule itself produced, such as the next backoff delay or the retry count. Returns true for outputs that may recur. The schedule whose output is checked. // Back off exponentially, but stop once the delay would reach 30 seconds Schedule.exponential (TimeSpan.FromMilliseconds 200.0) |> Schedule.whileOutput (fun delay -> delay < TimeSpan.FromSeconds 30.0)

Structural less-than comparison The first parameter. The second parameter. The result of the comparison. 1 < 5 // Evaluates to true 5 < 5 // Evaluates to false (1, "a") < (1, "z") // Evaluates to true

Returns a that represents a specified number of seconds, where the specification is accurate to the nearest millisecond. A number of seconds, accurate to the nearest millisecond. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Builds and combines schedules that decide whether, and after what delay, a flow runs again. Drive a schedule with Flow.retry (after typed failures), Flow.repeat (after successes), or FlowStream.fromSchedule (as a stream of its outputs). A schedule holds no state, so one value can drive any number of independent runs.

Creates a schedule that recurs with exponential backoff. The initial delay for the first retry. A schedule that recurs indefinitely, doubling the delay each time (baseDelay * 2^attempt) and capping at instead of overflowing. Thrown when is negative. let backoff () = Schedule.exponential (TimeSpan.FromMilliseconds 100.0) // Delays: 100ms, 200ms, 400ms, 800ms...

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Continues only while the schedule's output satisfies a predicate. Where whileInput looks at the error or value being retried, this looks at what the schedule itself produced, such as the next backoff delay or the retry count. Returns true for outputs that may recur. The schedule whose output is checked. // Back off exponentially, but stop once the delay would reach 30 seconds Schedule.exponential (TimeSpan.FromMilliseconds 200.0) |> Schedule.whileOutput (fun delay -> delay < TimeSpan.FromSeconds 30.0)

Structural less-than comparison The first parameter. The second parameter. The result of the comparison. 1 < 5 // Evaluates to true 5 < 5 // Evaluates to false (1, "a") < (1, "z") // Evaluates to true

An environment containing only a clock, for timed flows with no other services.

Represents an error channel that cannot occur.

The type 'unit', which has only one value "()". This value is special and always uses the representation 'null'. Basic Types

The universal flow { } computation expression.

Suspends the flow for the specified duration, observing cancellation. The duration to sleep. A flow that completes after the specified delay, or is interrupted if cancelled first.

Represents a time interval.

Returns a that represents a specified number of minutes, where the specification is accurate to the nearest millisecond. A number of minutes, accurate to the nearest millisecond. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

Creates a defective flow that fails with an exception. The exception representing the defect. A flow that always dies with the provided exception. This is the public constructor for non-domain defects. Use fail for expected typed failures and die when the workflow should surface a bug or panic.

Initializes a new instance of the class with a specified error message. The message that describes the error.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Restarts a flow that terminates with an unexpected defect, according to a schedule. The defect-channel sibling of retry: retry re-runs typed Cause.Fail errors and never touches defects, while supervise re-runs Cause.Die defects and never touches typed errors or interruptions. The schedule sees the first defect of each failed run. Each attempt runs in its own child scope, closed before the next attempt starts, so finalizers registered by a failed attempt are released instead of accumulating. Re-evaluation only resets state that lives inside the flow itself; mutable state in the environment is not restored. When the schedule stops, the final defect propagates as the flow's exit. Decides, from each defect, whether to restart and after what delay. The flow to supervise. A flow that re-evaluates Cause.Die outcomes while the schedule allows it. worker |> Flow.supervise (Retry.schedule { Retry.defaults with Retries = 5 })

Builds and combines schedules that decide whether, and after what delay, a flow runs again. Drive a schedule with Flow.retry (after typed failures), Flow.repeat (after successes), or FlowStream.fromSchedule (as a stream of its outputs). A schedule holds no state, so one value can drive any number of independent runs.

Creates a schedule that recurs a fixed number of times. counts the schedule's own decisions, not the total number of flow executions: Flow.retry and Flow.repeat always run the source flow once before consulting the schedule at all, so recurs 3 means 3 additional retries/repeats on top of that one free attempt: 4 executions in total, not 3. A Schedule value carries no state of its own (the attempt count lives in the retry/repeat call), so the same schedule value is safe to reuse across independent runs. The maximum number of additional times to recur, on top of the source flow's one free initial attempt. A schedule that recurs up to times, emitting the current attempt count (0 to n-1). let retryThreeTimes () = Schedule.recurs 3 // Flow.retry runs the source flow once for free, then consults the schedule at // attempts 0, 1, 2 (three retries) before giving up: 4 executions in total.

Starts a schedule's count again after a run that lasted at least . A long run means the failure that follows is new, not a continuation of earlier ones. With Flow.supervise, a worker that crashes after an hour of good work gets its full restart budget back instead of having used it up on crashes from the day before. The wrapped schedule then sees attempt 0 again, so recurs and exponential restart too. How long a run must last for the count to restart. The schedule whose count restarts. worker |> Flow.supervise (Schedule.recurs 5 |> Schedule.resetAfter (TimeSpan.FromMinutes 10.0))