arrow-resilience/arrow.resilience/Schedule

Schedule

value class Schedule<in Input, out Output>(val step: ScheduleStep<Input, Output>)(source)

A Schedule describes how a suspend fun should retry or repeat.

It's defined by a step function that takes an Input and returns a Decision, the Decision determines if the suspend fun should be Continue to be retried or repeated (and if so, the delay until the next attempt), or if the Schedule is Done retrying or repeating.

Constructors

Schedule

constructor(step: ScheduleStep<Input, Output>)

Types

Companion

object Companion

Decision

sealed interface Decision<in Input, out Output>

Properties

step

val step: ScheduleStep<Input, Output>

Functions

and

infix fun <B> and(other: Schedule<@UnsafeVariance Input, B>): Schedule<Input, Pair<Output, B>>

Combines two Schedules into one by combining the output of both Schedules into a Pair. It chooses the longest delay between the two Schedules. If one of the Schedules is done, the other Schedule is not executed anymore.

fun <B, C> and(other: Schedule<@UnsafeVariance Input, B>, transform: suspend (output: Output, b: B) -> C): Schedule<Input, C>

Combines two Schedules into one by transforming the output of both Schedules using transform. It chooses the longest delay between the two Schedules. If one of the Schedules is done, the other Schedule is not executed anymore.

fun <B, C> and(other: Schedule<@UnsafeVariance Input, B>, transform: suspend (output: Output, b: B) -> C, combineDuration: suspend (left: Duration, right: Duration) -> Duration): Schedule<Input, C>

Combines two Schedules into one by transforming the output of both Schedules using transform. It combines the delay of both Schedules using combineDuration. If one of the Schedules is done, the other Schedule is not executed anymore.

andThen

infix fun <A> andThen(other: Schedule<@UnsafeVariance Input, A>): Schedule<Input, Either<Output, A>>

Runs this schedule until Done, and then runs other until Done. Wrapping the output of this in Either.Left, and the output of other in Either.Right.

fun <A, B> andThen(other: Schedule<@UnsafeVariance Input, A>, ifLeft: suspend (Output) -> B, ifRight: suspend (A) -> B): Schedule<Input, B>

Runs this schedule, and transforms the output of this schedule using ifLeft, When this schedule is Done, it runs other schedule, and transforms the output using ifRight.

collect

fun collect(): Schedule<Input, List<Output>>

Collects all the Output of the Schedule into a List. This is useful in combination with identity to collect all the inputs.

contramap

fun <A> contramap(transform: suspend (A) -> Input): Schedule<A, Output>

Transform the Schedule by mapping the Input's.

delayed

fun delayed(transform: suspend (Output, Duration) -> Duration): Schedule<Input, Output>

Modify Continue.delay by the given function transform.

doUntil

fun doUntil(predicate: suspend (input: @UnsafeVariance Input, output: Output) -> Boolean): Schedule<Input, Output>

Runs the Schedule until the predicate of Input and Output returns true. Inverse version of doWhile.

doWhile

fun doWhile(predicate: suspend (@UnsafeVariance Input, Output) -> Boolean): Schedule<Input, Output>

Runs this Schedule while the predicate of Input and Output returns false.

fold

fun <B> fold(b: B, f: suspend (B, Output) -> B): Schedule<Input, B>

Folds all the Output of the Schedule into a List. This is useful in combination with identity to fold all the Input into a final value B. If one of the Schedules is done, the other Schedule is not executed anymore.

jittered

fun jittered(min: Double = 0.0, max: Double = 1.0, random: Random = Random.Default): Schedule<Input, Output>

Adds a Random jitter to the delay of the Schedule.

log

fun log(action: suspend (input: @UnsafeVariance Input, output: Output) -> Unit): Schedule<Input, Output>

Adds a logging action to the Schedule.

map

fun <A> map(transform: suspend (output: Output) -> A): Schedule<Input, A>

Transforms every Output'ed value of this schedule using transform.

mapDecision

fun mapDecision(f: suspend (Schedule.Decision<Input, Output>) -> Schedule.Decision<@UnsafeVariance Input, @UnsafeVariance Output>): Schedule<Input, Output>

fun <B, C> or(other: Schedule<@UnsafeVariance Input, B>, transform: suspend (output: Output?, b: B?) -> C, combineDuration: suspend (left: Duration?, right: Duration?) -> Duration): Schedule<Input, C>

Combines two Schedules into one by transforming the output of both Schedules using transform. It combines the delay of both Schedules using combineDuration. It continues to execute both Schedules until both are done, padding the output and duration with null if one of the Schedules is done.

repeat

suspend fun repeat(block: suspend () -> Input): Output

Repeat the schedule, and uses block as Input for the step function.

repeatOrElse

suspend fun repeatOrElse(block: suspend () -> Input, orElse: suspend (error: Throwable, output: Output?) -> @UnsafeVariance Output): Output

Repeat the schedule, and uses block as Input for the step function. If the step function throws an exception, it will be caught and passed to orElse.

repeatOrElseEither

suspend fun <A> repeatOrElseEither(block: suspend () -> Input, orElse: suspend (error: Throwable, output: Output?) -> A): Either<A, Output>

Repeat the schedule, and uses block as Input for the step function. If the step function throws an exception, it will be caught and passed to orElse. The resulting Either indicates if the step function threw an exception or not.

retry

suspend fun <A> Schedule<Throwable, *>.retry(action: suspend () -> A): A

Retries action using any Throwable that occurred as the input to the Schedule. It will throw the last exception if the Schedule is exhausted, and ignores the output of the Schedule.

retryEither

inline suspend fun <Error, Result, Output> Schedule<Error, Output>.retryEither(action: () -> Either<Error, Result>): Either<Error, Result>

Retries action using any Error that occurred as the input to the Schedule. It will return the last Error if the Schedule is exhausted, and ignores the output of the Schedule.

retryOrElse

suspend fun <Input, Output> Schedule<Throwable, Output>.retryOrElse(action: suspend () -> Input, orElse: suspend (Throwable, Output) -> Input): Input

retryOrElseEither

suspend fun <Input, Output, A> Schedule<Throwable, Output>.retryOrElseEither(action: suspend () -> Input, orElse: suspend (Throwable, Output) -> A): Either<A, Input>

Retries action using any Throwable that occurred as the input to the Schedule. If the Schedule is exhausted, it will invoke orElse with the last exception and the output of the Schedule to produce a fallback value of A. Returns Either with the fallback value if the Schedule is exhausted, or the successful result of action.

retryRaise

inline suspend fun <Error, Result, Output> Schedule<Error, Output>.retryRaise(action: Raise<Error>.() -> Result): Either<Error, Result>

Retries action using any Error that occurred as the input to the Schedule. It will return the last Error if the Schedule is exhausted, and ignores the output of the Schedule.

zipLeft

infix fun <B> zipLeft(other: Schedule<@UnsafeVariance Input, B>): Schedule<Input, Output>

Combines two Schedules into one, ignoring the output of other. It chooses the longest delay between the two Schedules. If one of the Schedules is done, the other Schedule is not executed anymore.

zipRight

infix fun <B> zipRight(other: Schedule<@UnsafeVariance Input, B>): Schedule<Input, B>

Combines two Schedules into one, ignoring the output of this Schedule. It chooses the longest delay between the two Schedules. If one of the Schedules is done, the other Schedule is not executed anymore.