trait Schedule[-Env, -In, +Out] extends Serializable
A Schedule[Env, In, Out]
defines a recurring schedule, which consumes
values of type In
, and which returns values of type Out
.
Schedules are defined as a possibly infinite set of intervals spread out over time. Each interval defines a window in which recurrence is possible.
When schedules are used to repeat or retry effects, the starting boundary of each interval produced by a schedule is used as the moment when the effect will be executed again.
Schedules compose in the following primary ways:
* Union. This performs the union of the intervals of two schedules. * Intersection. This performs the intersection of the intervals of two schedules. * Sequence. This concatenates the intervals of one schedule onto another.
In addition, schedule inputs and outputs can be transformed, filtered (to terminate a schedule early in response to some input or output), and so forth.
A variety of other operators exist for transforming and combining schedules,
and the companion object for Schedule
contains all common types of
schedules, both for performing retrying, as well as performing repetition.
- Self Type
- Schedule[Env, In, Out]
- Alphabetic
- By Inheritance
- Schedule
- Serializable
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- abstract type State
Abstract Value Members
- abstract def initial: State
- abstract def step(now: OffsetDateTime, in: In, state: State)(implicit trace: ZTraceElement): ZIO[Env, Nothing, (State, Out, Decision)]
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
&&[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]
Returns a new schedule that performs a geometric intersection on the intervals defined by both schedules.
-
def
***[Env1 <: Env, In2, Out2](that: Schedule[Env1, In2, Out2]): WithState[(State, State), Env1, (In, In2), (Out, Out2)]
Returns a new schedule that has both the inputs and outputs of this and the specified schedule.
-
def
*>[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State), Env1, In1, Out2]
The same as
&&
, but ignores the left output. -
def
++[Env1 <: Env, In1 <: In, Out2 >: Out](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State, Boolean), Env1, In1, Out2]
A symbolic alias for
andThen
. -
def
+++[Env1 <: Env, In2, Out2](that: Schedule[Env1, In2, Out2]): WithState[(State, State), Env1, Either[In, In2], Either[Out, Out2]]
Returns a new schedule that allows choosing between feeding inputs to this schedule, or feeding inputs to the specified schedule.
-
def
<*[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State), Env1, In1, Out]
The same as
&&
, but ignores the right output. -
def
<*>[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]
An operator alias for
zip
. -
def
<<<[Env1 <: Env, In2](that: Schedule[Env1, In2, In]): WithState[(State, State), Env1, In2, Out]
A backwards version of
>>>
. -
def
<||>[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2]): WithState[(State, State, Boolean), Env1, In1, Either[Out, Out2]]
Operator alias for
andThenEither
. -
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
>>>[Env1 <: Env, Out2](that: Schedule[Env1, Out, Out2]): WithState[(State, State), Env1, In, Out2]
Returns the composition of this schedule and the specified schedule, by piping the output of this one into the input of the other.
Returns the composition of this schedule and the specified schedule, by piping the output of this one into the input of the other. Effects described by this schedule will always be executed before the effects described by the second schedule.
-
def
addDelay(f: (Out) ⇒ zio.Duration)(implicit trace: ZTraceElement): WithState[State, Env, In, Out]
Returns a new schedule with the given delay added to every interval defined by this schedule.
-
def
addDelayZIO[Env1 <: Env](f: (Out) ⇒ URIO[Env1, zio.Duration])(implicit trace: ZTraceElement): WithState[State, Env1, In, Out]
Returns a new schedule with the given effectfully computed delay added to every interval defined by this schedule.
-
def
andThen[Env1 <: Env, In1 <: In, Out2 >: Out](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State, Boolean), Env1, In1, Out2]
The same as
andThenEither
, but merges the output. -
def
andThenEither[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2]): WithState[(State, State, Boolean), Env1, In1, Either[Out, Out2]]
Returns a new schedule that first executes this schedule to completion, and then executes the specified schedule to completion.
-
def
as[Out2](out2: ⇒ Out2)(implicit trace: ZTraceElement): WithState[State, Env, In, Out2]
Returns a new schedule that maps this schedule to a constant output.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
check[In1 <: In](test: (In1, Out) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[State, Env, In1, Out]
Returns a new schedule that passes each input and output of this schedule to the specified function, and then determines whether or not to continue based on the return value of the function.
-
def
checkZIO[Env1 <: Env, In1 <: In](test: (In1, Out) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In1, Out]
Returns a new schedule that passes each input and output of this schedule to the specified function, and then determines whether or not to continue based on the return value of the function.
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
collectAll[Out1 >: Out](implicit trace: ZTraceElement): WithState[(State, Chunk[Out1]), Env, In, Chunk[Out1]]
Returns a new schedule that collects the outputs of this one into a chunk.
-
def
compose[Env1 <: Env, In2](that: Schedule[Env1, In2, In]): WithState[(State, State), Env1, In2, Out]
A named alias for
<<<
. -
def
contramap[Env1 <: Env, In2](f: (In2) ⇒ In)(implicit trace: ZTraceElement): WithState[State, Env, In2, Out]
Returns a new schedule that deals with a narrower class of inputs than this schedule.
-
def
contramapZIO[Env1 <: Env, In2](f: (In2) ⇒ URIO[Env1, In]): WithState[State, Env1, In2, Out]
Returns a new schedule that deals with a narrower class of inputs than this schedule.
-
def
delayed(f: (zio.Duration) ⇒ zio.Duration)(implicit trace: ZTraceElement): WithState[State, Env, In, Out]
Returns a new schedule with the specified effectfully computed delay added before the start of each interval produced by this schedule.
-
def
delayedZIO[Env1 <: Env](f: (zio.Duration) ⇒ URIO[Env1, zio.Duration]): WithState[State, Env1, In, Out]
Returns a new schedule with the specified effectfully computed delay added before the start of each interval produced by this schedule.
-
def
delays: WithState[State, Env, In, zio.Duration]
Returns a new schedule that outputs the delay between each occurence.
-
def
dimap[In2, Out2](f: (In2) ⇒ In, g: (Out) ⇒ Out2)(implicit trace: ZTraceElement): WithState[State, Env, In2, Out2]
Returns a new schedule that contramaps the input and maps the output.
-
def
dimapZIO[Env1 <: Env, In2, Out2](f: (In2) ⇒ URIO[Env1, In], g: (Out) ⇒ URIO[Env1, Out2]): WithState[State, Env1, In2, Out2]
Returns a new schedule that contramaps the input and maps the output.
-
def
driver(implicit trace: ZTraceElement): URIO[Clock, Driver[State, Env, In, Out]]
Returns a driver that can be used to step the schedule, appropriately handling sleeping.
-
def
either[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2]): WithState[(State, State), Env1, In1, (Out, Out2)]
A named alias for
||
. -
def
eitherWith[Env1 <: Env, In1 <: In, Out2, Out3](that: Schedule[Env1, In1, Out2])(f: (Out, Out2) ⇒ Out3)(implicit trace: ZTraceElement): WithState[(State, State), Env1, In1, Out3]
The same as
either
followed bymap
. -
def
ensuring(finalizer: UIO[Any]): WithState[State, Env, In, Out]
Returns a new schedule that will run the specified finalizer as soon as the schedule is complete.
Returns a new schedule that will run the specified finalizer as soon as the schedule is complete. Note that unlike
ZIO#ensuring
, this method does not guarantee the finalizer will be run. TheSchedule
may not initialize or the driver of the schedule may not run to completion. However, if theSchedule
ever decides not to continue, then the finalizer will be run. -
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
first[X]: WithState[(State, Unit), Env, (In, X), (Out, X)]
Returns a new schedule that packs the input and output of this schedule into the first element of a tuple.
Returns a new schedule that packs the input and output of this schedule into the first element of a tuple. This allows carrying information through this schedule.
-
def
fold[Z](z: Z)(f: (Z, Out) ⇒ Z)(implicit trace: ZTraceElement): WithState[(State, Z), Env, In, Z]
Returns a new schedule that folds over the outputs of this one.
-
def
foldZIO[Env1 <: Env, Z](z: Z)(f: (Z, Out) ⇒ URIO[Env1, Z]): WithState[(State, Z), Env1, In, Z]
Returns a new schedule that effectfully folds over the outputs of this one.
-
def
forever: WithState[State, Env, In, Out]
Returns a new schedule that loops this one continuously, resetting the state when this schedule is done.
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
intersectWith[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(f: (Interval, Interval) ⇒ Interval)(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]
Returns a new schedule that combines this schedule with the specified schedule, continuing as long as both schedules want to continue and merging the next intervals according to the specified merge function.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
jittered(min: Double, max: Double)(implicit trace: ZTraceElement): WithState[State, Env with Random, In, Out]
Returns a new schedule that randomly modifies the size of the intervals of this schedule.
Returns a new schedule that randomly modifies the size of the intervals of this schedule.
The new interval size is between
min * old interval size
andmax * old interval size
. -
def
jittered(implicit trace: ZTraceElement): WithState[State, Env with Random, In, Out]
Returns a new schedule that randomly modifies the size of the intervals of this schedule.
-
def
left[X]: WithState[(State, Unit), Env, Either[In, X], Either[Out, X]]
Returns a new schedule that makes this schedule available on the
Left
side of anEither
input, allowing propagating some typeX
through this channel on demand. -
def
map[Out2](f: (Out) ⇒ Out2)(implicit trace: ZTraceElement): WithState[State, Env, In, Out2]
Returns a new schedule that maps the output of this schedule through the specified function.
-
def
mapZIO[Env1 <: Env, Out2](f: (Out) ⇒ URIO[Env1, Out2]): WithState[State, Env1, In, Out2]
Returns a new schedule that maps the output of this schedule through the specified effectful function.
-
def
modifyDelay(f: (Out, zio.Duration) ⇒ zio.Duration): WithState[State, Env, In, Out]
Returns a new schedule that modifies the delay using the specified function.
-
def
modifyDelayZIO[Env1 <: Env](f: (Out, zio.Duration) ⇒ URIO[Env1, zio.Duration]): WithState[State, Env1, In, Out]
Returns a new schedule that modifies the delay using the specified effectual function.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
onDecision[Env1 <: Env](f: (State, Out, Decision) ⇒ URIO[Env1, Any]): WithState[State, Env1, In, Out]
Returns a new schedule that applies the current one but runs the specified effect for every decision of this schedule.
Returns a new schedule that applies the current one but runs the specified effect for every decision of this schedule. This can be used to create schedules that log failures, decisions, or computed values.
-
def
provideEnvironment(env: ZEnvironment[Env]): WithState[State, Any, In, Out]
Returns a new schedule with its environment provided to it, so the resulting schedule does not require any environment.
-
def
provideService[Service <: Env](service: Service)(implicit tag: Tag[Service]): WithState[State, Any, In, Out]
Returns a new schedule with the single service it requires provided to it.
Returns a new schedule with the single service it requires provided to it. If the schedule requires multiple services use
provideEnvironment
instead. -
def
provideSomeEnvironment[Env2](f: (ZEnvironment[Env2]) ⇒ ZEnvironment[Env]): WithState[State, Env2, In, Out]
Transforms the environment being provided to this schedule with the specified function.
-
def
reconsider[Out2](f: (State, Out, Decision) ⇒ Either[Out2, (Out2, Interval)])(implicit trace: ZTraceElement): WithState[State, Env, In, Out2]
Returns a new schedule that reconsiders every decision made by this schedule, possibly modifying the next interval and the output type in the process.
-
def
reconsiderZIO[Env1 <: Env, In1 <: In, Out2](f: (State, Out, Decision) ⇒ URIO[Env1, Either[Out2, (Out2, Interval)]]): WithState[State, Env1, In1, Out2]
Returns a new schedule that effectfully reconsiders every decision made by this schedule, possibly modifying the next interval and the output type in the process.
-
def
repetitions(implicit trace: ZTraceElement): WithState[(State, Long), Env, In, Long]
Returns a new schedule that outputs the number of repetitions of this one.
-
final
def
resetAfter(duration: zio.Duration)(implicit trace: ZTraceElement): WithState[(State, Option[OffsetDateTime]), Env, In, Out]
Return a new schedule that automatically resets the schedule to its initial state after some time of inactivity defined by
duration
. -
final
def
resetWhen(f: (Out) ⇒ Boolean): WithState[State, Env, In, Out]
Resets the schedule when the specified predicate on the schedule output evaluates to true.
-
def
right[X]: WithState[(Unit, State), Env, Either[X, In], Either[X, Out]]
Returns a new schedule that makes this schedule available on the
Right
side of anEither
input, allowing propagating some typeX
through this channel on demand. -
def
run(now: OffsetDateTime, input: Iterable[In])(implicit trace: ZTraceElement): URIO[Env, Chunk[Out]]
Runs a schedule using the provided inputs, and collects all outputs.
-
def
second[X]: WithState[(Unit, State), Env, (X, In), (X, Out)]
Returns a new schedule that packs the input and output of this schedule into the second element of a tuple.
Returns a new schedule that packs the input and output of this schedule into the second element of a tuple. This allows carrying information through this schedule.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
tapInput[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Any]): WithState[State, Env1, In1, Out]
Returns a new schedule that effectfully processes every input to this schedule.
-
def
tapOutput[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Any]): WithState[State, Env1, In, Out]
Returns a new schedule that effectfully processes every output from this schedule.
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
unionWith[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(f: (Interval, Interval) ⇒ Interval)(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]
Returns a new schedule that combines this schedule with the specified schedule, continuing as long as either schedule wants to continue and merging the next intervals according to the specified merge function.
-
def
unit(implicit trace: ZTraceElement): WithState[State, Env, In, Unit]
Returns a new schedule that maps the output of this schedule to unit.
-
def
untilInput[In1 <: In](f: (In1) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[State, Env, In1, Out]
Returns a new schedule that continues until the specified predicate on the input evaluates to true.
-
def
untilInputZIO[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Boolean])(implicit trace: ZTraceElement): WithState[State, Env1, In1, Out]
Returns a new schedule that continues until the specified effectful predicate on the input evaluates to true.
-
def
untilOutput(f: (Out) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[State, Env, In, Out]
Returns a new schedule that continues until the specified predicate on the output evaluates to true.
-
def
untilOutputZIO[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Boolean])(implicit trace: ZTraceElement): WithState[State, Env1, In, Out]
Returns a new schedule that continues until the specified effectful predicate on the output evaluates to true.
-
def
upTo(duration: zio.Duration)(implicit trace: ZTraceElement): WithState[(State, Option[OffsetDateTime]), Env, In, Out]
A schedule that recurs during the given duration
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
whileInput[In1 <: In](f: (In1) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[State, Env, In1, Out]
Returns a new schedule that continues for as long the specified predicate on the input evaluates to true.
-
def
whileInputZIO[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In1, Out]
Returns a new schedule that continues for as long the specified effectful predicate on the input evaluates to true.
-
def
whileOutput(f: (Out) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[State, Env, In, Out]
Returns a new schedule that continues for as long the specified predicate on the output evaluates to true.
-
def
whileOutputZIO[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In, Out]
Returns a new schedule that continues for as long the specified effectful predicate on the output evaluates to true.
-
def
zip[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]
A named method for
&&
. -
def
zipLeft[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State), Env1, In1, Out]
The same as
&&
, but ignores the right output. -
def
zipRight[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State), Env1, In1, Out2]
The same as
&&
, but ignores the left output. -
def
zipWith[Env1 <: Env, In1 <: In, Out2, Out3](that: Schedule[Env1, In1, Out2])(f: (Out, Out2) ⇒ Out3)(implicit trace: ZTraceElement): WithState[(State, State), Env1, In1, Out3]
Equivalent to
zip
followed bymap
. -
def
||[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]
Returns a new schedule that performs a geometric union on the intervals defined by both schedules.
-
def
|||[Env1 <: Env, Out1 >: Out, In2](that: Schedule[Env1, In2, Out1])(implicit trace: ZTraceElement): WithState[(State, State), Env1, Either[In, In2], Out1]
Returns a new schedule that chooses between two schedules with a common output.
Deprecated Value Members
-
def
addDelayM[Env1 <: Env](f: (Out) ⇒ URIO[Env1, zio.Duration])(implicit trace: ZTraceElement): WithState[State, Env1, In, Out]
Returns a new schedule with the given effectfully computed delay added to every interval defined by this schedule.
Returns a new schedule with the given effectfully computed delay added to every interval defined by this schedule.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use addDelayZIO
-
def
checkM[Env1 <: Env, In1 <: In](test: (In1, Out) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In1, Out]
Returns a new schedule that passes each input and output of this schedule to the specified function, and then determines whether or not to continue based on the return value of the function.
Returns a new schedule that passes each input and output of this schedule to the specified function, and then determines whether or not to continue based on the return value of the function.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use checkZIO
-
def
contramapM[Env1 <: Env, In2](f: (In2) ⇒ URIO[Env1, In]): WithState[State, Env1, In2, Out]
Returns a new schedule that deals with a narrower class of inputs than this schedule.
Returns a new schedule that deals with a narrower class of inputs than this schedule.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use contramapZIO
-
def
delayedM[Env1 <: Env](f: (zio.Duration) ⇒ URIO[Env1, zio.Duration]): WithState[State, Env1, In, Out]
Returns a new schedule with the specified effectfully computed delay added before the start of each interval produced by this schedule.
Returns a new schedule with the specified effectfully computed delay added before the start of each interval produced by this schedule.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use delayedZIO
-
def
dimapM[Env1 <: Env, In2, Out2](f: (In2) ⇒ URIO[Env1, In], g: (Out) ⇒ URIO[Env1, Out2]): WithState[State, Env1, In2, Out2]
Returns a new schedule that contramaps the input and maps the output.
Returns a new schedule that contramaps the input and maps the output.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use dimapZIO
-
def
foldM[Env1 <: Env, Z](z: Z)(f: (Z, Out) ⇒ URIO[Env1, Z]): WithState[(State, Z), Env1, In, Z]
Returns a new schedule that effectfully folds over the outputs of this one.
Returns a new schedule that effectfully folds over the outputs of this one.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use foldZIO
-
def
mapM[Env1 <: Env, Out2](f: (Out) ⇒ URIO[Env1, Out2]): WithState[State, Env1, In, Out2]
Returns a new schedule that maps the output of this schedule through the specified effectful function.
Returns a new schedule that maps the output of this schedule through the specified effectful function.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use mapZIO
-
def
modifyDelayM[Env1 <: Env](f: (Out, zio.Duration) ⇒ URIO[Env1, zio.Duration]): WithState[State, Env1, In, Out]
Returns a new schedule that modifies the delay using the specified effectual function.
Returns a new schedule that modifies the delay using the specified effectual function.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use modifyDelayZIO
-
def
reconsiderM[Env1 <: Env, In1 <: In, Out2](f: (State, Out, Decision) ⇒ URIO[Env1, Either[Out2, (Out2, Interval)]]): WithState[State, Env1, In1, Out2]
Returns a new schedule that effectfully reconsiders every decision made by this schedule, possibly modifying the next interval and the output type in the process.
Returns a new schedule that effectfully reconsiders every decision made by this schedule, possibly modifying the next interval and the output type in the process.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use reconsiderZIO
-
def
untilInputM[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Boolean])(implicit trace: ZTraceElement): WithState[State, Env1, In1, Out]
Returns a new schedule that continues until the specified effectful predicate on the input evaluates to true.
Returns a new schedule that continues until the specified effectful predicate on the input evaluates to true.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use untilInputZIO
-
def
untilOutputM[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Boolean])(implicit trace: ZTraceElement): WithState[State, Env1, In, Out]
Returns a new schedule that continues until the specified effectful predicate on the output evaluates to true.
Returns a new schedule that continues until the specified effectful predicate on the output evaluates to true.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use untilOutputZIO
-
def
whileInputM[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In1, Out]
Returns a new schedule that continues for as long the specified effectful predicate on the input evaluates to true.
Returns a new schedule that continues for as long the specified effectful predicate on the input evaluates to true.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use whileInputZIO
-
def
whileOutputM[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In, Out]
Returns a new schedule that continues for as long the specified effectful predicate on the output evaluates to true.
Returns a new schedule that continues for as long the specified effectful predicate on the output evaluates to true.
- Annotations
- @deprecated
- Deprecated
(Since version 2.0.0) use whileOutputZIO