Trait/Object

zio

Schedule

Related Docs: object Schedule | package zio

Permalink

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]
Linear Supertypes
Serializable, Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Schedule
  2. Serializable
  3. Serializable
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. abstract type State

    Permalink

Abstract Value Members

  1. abstract def initial: State

    Permalink

  2. abstract def step(now: OffsetDateTime, in: In, state: State)(implicit trace: ZTraceElement): ZIO[Env, Nothing, (State, Out, Decision)]

    Permalink

Concrete Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any

  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any

  3. def &&[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]

    Permalink

    Returns a new schedule that performs a geometric intersection on the intervals defined by both schedules.

  4. def ***[Env1 <: Env, In2, Out2](that: Schedule[Env1, In2, Out2]): WithState[(State, State), Env1, (In, In2), (Out, Out2)]

    Permalink

    Returns a new schedule that has both the inputs and outputs of this and the specified schedule.

  5. def *>[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State), Env1, In1, Out2]

    Permalink

    The same as &&, but ignores the left output.

  6. def ++[Env1 <: Env, In1 <: In, Out2 >: Out](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State, Boolean), Env1, In1, Out2]

    Permalink

    A symbolic alias for andThen.

  7. def +++[Env1 <: Env, In2, Out2](that: Schedule[Env1, In2, Out2]): WithState[(State, State), Env1, Either[In, In2], Either[Out, Out2]]

    Permalink

    Returns a new schedule that allows choosing between feeding inputs to this schedule, or feeding inputs to the specified schedule.

  8. def <*[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State), Env1, In1, Out]

    Permalink

    The same as &&, but ignores the right output.

  9. def <*>[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]

    Permalink

    An operator alias for zip.

  10. def <<<[Env1 <: Env, In2](that: Schedule[Env1, In2, In]): WithState[(State, State), Env1, In2, Out]

    Permalink

    A backwards version of >>>.

  11. def <||>[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2]): WithState[(State, State, Boolean), Env1, In1, Either[Out, Out2]]

    Permalink

    Operator alias for andThenEither.

  12. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any

  13. def >>>[Env1 <: Env, Out2](that: Schedule[Env1, Out, Out2]): WithState[(State, State), Env1, In, Out2]

    Permalink

    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.

  14. def addDelay(f: (Out) ⇒ zio.Duration)(implicit trace: ZTraceElement): WithState[State, Env, In, Out]

    Permalink

    Returns a new schedule with the given delay added to every interval defined by this schedule.

  15. def addDelayZIO[Env1 <: Env](f: (Out) ⇒ URIO[Env1, zio.Duration])(implicit trace: ZTraceElement): WithState[State, Env1, In, Out]

    Permalink

    Returns a new schedule with the given effectfully computed delay added to every interval defined by this schedule.

  16. def andThen[Env1 <: Env, In1 <: In, Out2 >: Out](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State, Boolean), Env1, In1, Out2]

    Permalink

    The same as andThenEither, but merges the output.

  17. def andThenEither[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2]): WithState[(State, State, Boolean), Env1, In1, Either[Out, Out2]]

    Permalink

    Returns a new schedule that first executes this schedule to completion, and then executes the specified schedule to completion.

  18. def as[Out2](out2: ⇒ Out2)(implicit trace: ZTraceElement): WithState[State, Env, In, Out2]

    Permalink

    Returns a new schedule that maps this schedule to a constant output.

  19. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any

  20. def check[In1 <: In](test: (In1, Out) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[State, Env, In1, Out]

    Permalink

    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.

  21. def checkZIO[Env1 <: Env, In1 <: In](test: (In1, Out) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In1, Out]

    Permalink

    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.

  22. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  23. def collectAll[Out1 >: Out](implicit trace: ZTraceElement): WithState[(State, Chunk[Out1]), Env, In, Chunk[Out1]]

    Permalink

    Returns a new schedule that collects the outputs of this one into a chunk.

  24. def compose[Env1 <: Env, In2](that: Schedule[Env1, In2, In]): WithState[(State, State), Env1, In2, Out]

    Permalink

    A named alias for <<<.

  25. def contramap[Env1 <: Env, In2](f: (In2) ⇒ In)(implicit trace: ZTraceElement): WithState[State, Env, In2, Out]

    Permalink

    Returns a new schedule that deals with a narrower class of inputs than this schedule.

  26. def contramapZIO[Env1 <: Env, In2](f: (In2) ⇒ URIO[Env1, In]): WithState[State, Env1, In2, Out]

    Permalink

    Returns a new schedule that deals with a narrower class of inputs than this schedule.

  27. def delayed(f: (zio.Duration) ⇒ zio.Duration)(implicit trace: ZTraceElement): WithState[State, Env, In, Out]

    Permalink

    Returns a new schedule with the specified effectfully computed delay added before the start of each interval produced by this schedule.

  28. def delayedZIO[Env1 <: Env](f: (zio.Duration) ⇒ URIO[Env1, zio.Duration]): WithState[State, Env1, In, Out]

    Permalink

    Returns a new schedule with the specified effectfully computed delay added before the start of each interval produced by this schedule.

  29. def delays: WithState[State, Env, In, zio.Duration]

    Permalink

    Returns a new schedule that outputs the delay between each occurence.

  30. def dimap[In2, Out2](f: (In2) ⇒ In, g: (Out) ⇒ Out2)(implicit trace: ZTraceElement): WithState[State, Env, In2, Out2]

    Permalink

    Returns a new schedule that contramaps the input and maps the output.

  31. def dimapZIO[Env1 <: Env, In2, Out2](f: (In2) ⇒ URIO[Env1, In], g: (Out) ⇒ URIO[Env1, Out2]): WithState[State, Env1, In2, Out2]

    Permalink

    Returns a new schedule that contramaps the input and maps the output.

  32. def driver(implicit trace: ZTraceElement): URIO[Clock, Driver[State, Env, In, Out]]

    Permalink

    Returns a driver that can be used to step the schedule, appropriately handling sleeping.

  33. def either[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2]): WithState[(State, State), Env1, In1, (Out, Out2)]

    Permalink

    A named alias for ||.

  34. 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]

    Permalink

    The same as either followed by map.

  35. def ensuring(finalizer: UIO[Any]): WithState[State, Env, In, Out]

    Permalink

    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. The Schedule may not initialize or the driver of the schedule may not run to completion. However, if the Schedule ever decides not to continue, then the finalizer will be run.

  36. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef

  37. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any

  38. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

  39. def first[X]: WithState[(State, Unit), Env, (In, X), (Out, X)]

    Permalink

    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.

  40. def fold[Z](z: Z)(f: (Z, Out) ⇒ Z)(implicit trace: ZTraceElement): WithState[(State, Z), Env, In, Z]

    Permalink

    Returns a new schedule that folds over the outputs of this one.

  41. def foldZIO[Env1 <: Env, Z](z: Z)(f: (Z, Out) ⇒ URIO[Env1, Z]): WithState[(State, Z), Env1, In, Z]

    Permalink

    Returns a new schedule that effectfully folds over the outputs of this one.

  42. def forever: WithState[State, Env, In, Out]

    Permalink

    Returns a new schedule that loops this one continuously, resetting the state when this schedule is done.

  43. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any

  44. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any

  45. 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]

    Permalink

    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.

  46. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any

  47. def jittered(min: Double, max: Double)(implicit trace: ZTraceElement): WithState[State, Env with Random, In, Out]

    Permalink

    Returns a new schedule that randomly modifies the size of the intervals of this schedule.

  48. def jittered(implicit trace: ZTraceElement): WithState[State, Env with Random, In, Out]

    Permalink

    Returns a new schedule that randomly modifies the size of the intervals of this schedule.

  49. def left[X]: WithState[(State, Unit), Env, Either[In, X], Either[Out, X]]

    Permalink

    Returns a new schedule that makes this schedule available on the Left side of an Either input, allowing propagating some type X through this channel on demand.

  50. def map[Out2](f: (Out) ⇒ Out2)(implicit trace: ZTraceElement): WithState[State, Env, In, Out2]

    Permalink

    Returns a new schedule that maps the output of this schedule through the specified function.

  51. def mapZIO[Env1 <: Env, Out2](f: (Out) ⇒ URIO[Env1, Out2]): WithState[State, Env1, In, Out2]

    Permalink

    Returns a new schedule that maps the output of this schedule through the specified effectful function.

  52. def modifyDelay(f: (Out, zio.Duration) ⇒ zio.Duration): WithState[State, Env, In, Out]

    Permalink

    Returns a new schedule that modifies the delay using the specified function.

  53. def modifyDelayZIO[Env1 <: Env](f: (Out, zio.Duration) ⇒ URIO[Env1, zio.Duration]): WithState[State, Env1, In, Out]

    Permalink

    Returns a new schedule that modifies the delay using the specified effectual function.

  54. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef

  55. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef

  56. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef

  57. def onDecision[Env1 <: Env](f: (State, Out, Decision) ⇒ URIO[Env1, Any]): WithState[State, Env1, In, Out]

    Permalink

    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.

  58. def provideEnvironment(env: ZEnvironment[Env]): WithState[State, Any, In, Out]

    Permalink

    Returns a new schedule with its environment provided to it, so the resulting schedule does not require any environment.

  59. def provideSomeEnvironment[Env2](f: (ZEnvironment[Env2]) ⇒ ZEnvironment[Env]): WithState[State, Env2, In, Out]

    Permalink

    Transforms the environment being provided to this schedule with the specified function.

  60. def reconsider[Out2](f: (State, Out, Decision) ⇒ Either[Out2, (Out2, Interval)])(implicit trace: ZTraceElement): WithState[State, Env, In, Out2]

    Permalink

    Returns a new schedule that reconsiders every decision made by this schedule, possibly modifying the next interval and the output type in the process.

  61. def reconsiderZIO[Env1 <: Env, In1 <: In, Out2](f: (State, Out, Decision) ⇒ URIO[Env1, Either[Out2, (Out2, Interval)]]): WithState[State, Env1, In1, Out2]

    Permalink

    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.

  62. def repetitions(implicit trace: ZTraceElement): WithState[(State, Long), Env, In, Long]

    Permalink

    Returns a new schedule that outputs the number of repetitions of this one.

  63. final def resetAfter(duration: zio.Duration)(implicit trace: ZTraceElement): WithState[(State, Option[OffsetDateTime]), Env, In, Out]

    Permalink

    Return a new schedule that automatically resets the schedule to its initial state after some time of inactivity defined by duration.

  64. final def resetWhen(f: (Out) ⇒ Boolean): WithState[State, Env, In, Out]

    Permalink

    Resets the schedule when the specified predicate on the schedule output evaluates to true.

  65. def right[X]: WithState[(Unit, State), Env, Either[X, In], Either[X, Out]]

    Permalink

    Returns a new schedule that makes this schedule available on the Right side of an Either input, allowing propagating some type X through this channel on demand.

  66. def run(now: OffsetDateTime, input: Iterable[In])(implicit trace: ZTraceElement): URIO[Env, Chunk[Out]]

    Permalink

    Runs a schedule using the provided inputs, and collects all outputs.

  67. def second[X]: WithState[(Unit, State), Env, (X, In), (X, Out)]

    Permalink

    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.

  68. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef

  69. def tapInput[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Any]): WithState[State, Env1, In1, Out]

    Permalink

    Returns a new schedule that effectfully processes every input to this schedule.

  70. def tapOutput[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Any]): WithState[State, Env1, In, Out]

    Permalink

    Returns a new schedule that effectfully processes every output from this schedule.

  71. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any

  72. 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]

    Permalink

    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.

  73. def unit(implicit trace: ZTraceElement): WithState[State, Env, In, Unit]

    Permalink

    Returns a new schedule that maps the output of this schedule to unit.

  74. def untilInput[In1 <: In](f: (In1) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[State, Env, In1, Out]

    Permalink

    Returns a new schedule that continues until the specified predicate on the input evaluates to true.

  75. def untilInputZIO[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Boolean])(implicit trace: ZTraceElement): WithState[State, Env1, In1, Out]

    Permalink

    Returns a new schedule that continues until the specified effectful predicate on the input evaluates to true.

  76. def untilOutput(f: (Out) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[State, Env, In, Out]

    Permalink

    Returns a new schedule that continues until the specified predicate on the output evaluates to true.

  77. def untilOutputZIO[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Boolean])(implicit trace: ZTraceElement): WithState[State, Env1, In, Out]

    Permalink

    Returns a new schedule that continues until the specified effectful predicate on the output evaluates to true.

  78. def upTo(duration: zio.Duration)(implicit trace: ZTraceElement): WithState[(State, Option[OffsetDateTime]), Env, In, Out]

    Permalink

    A schedule that recurs during the given duration

  79. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  80. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  81. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  82. def whileInput[In1 <: In](f: (In1) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[State, Env, In1, Out]

    Permalink

    Returns a new schedule that continues for as long the specified predicate on the input evaluates to true.

  83. def whileInputZIO[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In1, Out]

    Permalink

    Returns a new schedule that continues for as long the specified effectful predicate on the input evaluates to true.

  84. def whileOutput(f: (Out) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[State, Env, In, Out]

    Permalink

    Returns a new schedule that continues for as long the specified predicate on the output evaluates to true.

  85. def whileOutputZIO[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In, Out]

    Permalink

    Returns a new schedule that continues for as long the specified effectful predicate on the output evaluates to true.

  86. def zip[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]

    Permalink

    A named method for &&.

  87. def zipLeft[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State), Env1, In1, Out]

    Permalink

    The same as &&, but ignores the right output.

  88. def zipRight[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: ZTraceElement): WithState[(State, State), Env1, In1, Out2]

    Permalink

    The same as &&, but ignores the left output.

  89. 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]

    Permalink

    Equivalent to zip followed by map.

  90. def ||[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]

    Permalink

    Returns a new schedule that performs a geometric union on the intervals defined by both schedules.

  91. def |||[Env1 <: Env, Out1 >: Out, In2](that: Schedule[Env1, In2, Out1])(implicit trace: ZTraceElement): WithState[(State, State), Env1, Either[In, In2], Out1]

    Permalink

    Returns a new schedule that chooses between two schedules with a common output.

Deprecated Value Members

  1. def addDelayM[Env1 <: Env](f: (Out) ⇒ URIO[Env1, zio.Duration])(implicit trace: ZTraceElement): WithState[State, Env1, In, Out]

    Permalink

    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

  2. def checkM[Env1 <: Env, In1 <: In](test: (In1, Out) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In1, Out]

    Permalink

    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

  3. def contramapM[Env1 <: Env, In2](f: (In2) ⇒ URIO[Env1, In]): WithState[State, Env1, In2, Out]

    Permalink

    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

  4. def delayedM[Env1 <: Env](f: (zio.Duration) ⇒ URIO[Env1, zio.Duration]): WithState[State, Env1, In, Out]

    Permalink

    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

  5. def dimapM[Env1 <: Env, In2, Out2](f: (In2) ⇒ URIO[Env1, In], g: (Out) ⇒ URIO[Env1, Out2]): WithState[State, Env1, In2, Out2]

    Permalink

    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

  6. def foldM[Env1 <: Env, Z](z: Z)(f: (Z, Out) ⇒ URIO[Env1, Z]): WithState[(State, Z), Env1, In, Z]

    Permalink

    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

  7. def mapM[Env1 <: Env, Out2](f: (Out) ⇒ URIO[Env1, Out2]): WithState[State, Env1, In, Out2]

    Permalink

    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

  8. def modifyDelayM[Env1 <: Env](f: (Out, zio.Duration) ⇒ URIO[Env1, zio.Duration]): WithState[State, Env1, In, Out]

    Permalink

    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

  9. def reconsiderM[Env1 <: Env, In1 <: In, Out2](f: (State, Out, Decision) ⇒ URIO[Env1, Either[Out2, (Out2, Interval)]]): WithState[State, Env1, In1, Out2]

    Permalink

    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

  10. def untilInputM[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Boolean])(implicit trace: ZTraceElement): WithState[State, Env1, In1, Out]

    Permalink

    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

  11. def untilOutputM[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Boolean])(implicit trace: ZTraceElement): WithState[State, Env1, In, Out]

    Permalink

    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

  12. def whileInputM[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In1, Out]

    Permalink

    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

  13. def whileOutputM[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In, Out]

    Permalink

    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

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped