Λrrow Fx

Extensions for arrow.Kind

fix	`fun <A>` `IOOf<A>.~~fix~~():` `IO<A>` `fun <F, A>` `QueueOf<F, A>.fix():` `Queue<F, A>` `fun <F, E, A>` `ResourceOf<F, E, A>.fix():` `Resource<F, E, A>` `fun <M, Input, Output>` `ScheduleOf<M, Input, Output>.fix():` `Schedule<M, Input, Output>` `fun <A, B>` `DecisionOf<A, B>.fix(): Decision<A, B>`
handleError	Handle the error by mapping the error to a value of A.`fun <A>` `IOOf<A>.handleError(f: (Throwable) -> A):` `IO<A>`
handleErrorWith	Handle the error by resolving the error with an effect that results in A.`fun <A>` `IOOf<A>.handleErrorWith(f: (Throwable) ->` `IOOf<A>):` `IO<A>`
repeat	`fun <A, B>` `IOOf<A>.repeat(schedule:` `Schedule<ForIO, A, B>):` `IO<B>` Run this effect once and, if it succeeded, decide using the passed policy if the effect should be repeated and if so, with how much delay. Returns the last output from the policy or raises an error if a repeat failed.`fun <F, A, B> Kind<F, A>.~~repeat~~(CF:` `Concurrent<F>, schedule:` `Schedule<F, A, B>): Kind<F, B>` `fun <F, E, A, B> Kind<F, A>.~~repeat~~(ME: MonadError<F, E>, T:` `Timer<F>, schedule:` `Schedule<F, A, B>): Kind<F, B>`
repeatOrElse	Run this effect once and, if it succeeded, decide using the passed policy if the effect should be repeated and if so, with how much delay. Also offers a function to handle errors if they are encountered during repetition.`fun <F, A, B> Kind<F, A>.~~repeatOrElse~~(CF:` `Concurrent<F>, schedule:` `Schedule<F, A, B>, orElse: (Throwable, Option<B>) -> Kind<F, B>): Kind<F, B>` `fun <F, E, A, B> Kind<F, A>.~~repeatOrElse~~(ME: MonadError<F, E>, T:` `Timer<F>, schedule:` `Schedule<F, A, B>, orElse: (E, Option<B>) -> Kind<F, B>): Kind<F, B>`
repeatOrElseEither	Run this effect once and, if it succeeded, decide using the passed policy if the effect should be repeated and if so, with how much delay. Also offers a function to handle errors if they are encountered during repetition.`fun <F, A, B, C> Kind<F, A>.~~repeatOrElseEither~~(CF:` `Concurrent<F>, schedule:` `Schedule<F, A, B>, orElse: (Throwable, Option<B>) -> Kind<F, C>): Kind<F, Either<C, B>>` `fun <F, E, A, B, C> Kind<F, A>.~~repeatOrElseEither~~(ME: MonadError<F, E>, T:` `Timer<F>, schedule:` `Schedule<F, A, B>, orElse: (E, Option<B>) -> Kind<F, C>): Kind<F, Either<C, B>>`
retry	`fun <A, B>` `IOOf<A>.retry(schedule:` `Schedule<ForIO,` `Throwable, B>):` `IO<A>` Run an effect and, if it fails, decide using the passed policy if the effect should be retried and if so, with how much delay. Returns the result of the effect if if it was successful or re-raises the last error encountered when the schedule ends.`fun <F, A, B> Kind<F, A>.~~retry~~(CF:` `Concurrent<F>, schedule:` `Schedule<F,` `Throwable, B>): Kind<F, A>` `fun <F, E, A, B> Kind<F, A>.~~retry~~(ME: MonadError<F, E>, T:` `Timer<F>, schedule:` `Schedule<F, E, B>): Kind<F, A>`
retryOrElse	Run an effect and, if it fails, decide using the passed policy if the effect should be retried and if so, with how much delay. Also offers a function to handle errors if they are encountered during retrial.`fun <F, A, B> Kind<F, A>.~~retryOrElse~~(CF:` `Concurrent<F>, schedule:` `Schedule<F,` `Throwable, B>, orElse: (Throwable, B) -> Kind<F, A>): Kind<F, A>` `fun <F, E, A, B> Kind<F, A>.~~retryOrElse~~(ME: MonadError<F, E>, T:` `Timer<F>, schedule:` `Schedule<F, E, B>, orElse: (E, B) -> Kind<F, A>): Kind<F, A>`
retryOrElseEither	Run an effect and, if it fails, decide using the passed policy if the effect should be retried and if so, with how much delay. Also offers a function to handle errors if they are encountered during retrial.`fun <F, A, B, C> Kind<F, A>.~~retryOrElseEither~~(CF:` `Concurrent<F>, schedule:` `Schedule<F,` `Throwable, B>, orElse: (Throwable, B) -> Kind<F, C>): Kind<F, Either<C, A>>` `fun <F, E, A, B, C> Kind<F, A>.~~retryOrElseEither~~(ME: MonadError<F, E>, T:` `Timer<F>, schedule:` `Schedule<F, E, B>, orElse: (E, B) -> Kind<F, C>): Kind<F, Either<C, A>>`
void	`fun <A>` `IOOf<A>.void():` `IO<Unit>`