Schedule

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def apply[R, S, A, B](initial0: ZIO[R, Nothing, S], update0: (A, S) ⇒ ZIO[R, Nothing, S], extract0: (A, S) ⇒ B): Schedule[R, A, B]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def collectAll[A]: Schedule[Any, A, List[A]]

A schedule that recurs forever, collecting all inputs into a list.

final def collectUntil[A](f: (A) ⇒ Boolean): Schedule[Any, A, List[A]]

A schedule that recurs until the condition f failes, collecting all inputs into a list.

final def collectUntilM[A](f: (A) ⇒ UIO[Boolean]): Schedule[Any, A, List[A]]

A schedule that recurs until the effectful condition f failes, collecting all inputs into a list.

final def collectWhile[A](f: (A) ⇒ Boolean): Schedule[Any, A, List[A]]

A schedule that recurs as long as the condition f holds, collecting all inputs into a list.

final def collectWhileM[A](f: (A) ⇒ UIO[Boolean]): Schedule[Any, A, List[A]]

A schedule that recurs as long as the effectful condition holds, collecting all inputs into a list.

final def delayed[R <: Clock, A](s: Schedule[R, A, Duration]): Schedule[R, A, Duration]

A new schedule derived from the specified schedule which transforms the delays into effectful sleeps.

final def doUntil[A, B](pf: PartialFunction[A, B]): Schedule[Any, A, Option[B]]

A schedule that recurs for until the input value becomes applicable to partial function and then map that value with given function.

final def doUntil[A](f: (A) ⇒ Boolean): Schedule[Any, A, A]

A schedule that recurs for until the predicate evaluates to true.

final def doUntilEquals[A](a: A): Schedule[Any, A, A]

A schedule that recurs for until the predicate is equal.

final def doUntilM[A](f: (A) ⇒ UIO[Boolean]): Schedule[Any, A, A]

A schedule that recurs for until the predicate evaluates to true.

final def doWhile[A](f: (A) ⇒ Boolean): Schedule[Any, A, A]

A schedule that recurs for as long as the predicate evaluates to true.

final def doWhileEquals[A](a: A): Schedule[Any, A, A]

A schedule that recurs for as long as the predicate is equal.

final def doWhileM[A](f: (A) ⇒ UIO[Boolean]): Schedule[Any, A, A]

A schedule that recurs for as long as the effectful predicate evaluates to true.

final def duration(duration: Duration): Schedule[Clock, Any, Duration]

A schedule that will recur until the specified duration elapses.

final val elapsed: Schedule[Clock, Any, Duration]

A schedule that recurs forever without delay.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def exponential(base: Duration, factor: Double = 2.0): Schedule[Clock, Any, Duration]

A schedule that always recurs, but will wait a certain amount between repetitions, given by base * factor.pow(n), where n is the number of repetitions so far.

final def fibonacci(one: Duration): Schedule[Clock, Any, Duration]

A schedule that always recurs, increasing delays by summing the preceding two delays (similar to the fibonacci sequence).

def finalize(): Unit

final def fixed(interval: Duration): Schedule[Clock, Any, Int]

A schedule that recurs on a fixed interval.

|---------interval---------|---------interval---------|
|action|                   |action|

final val forever: Schedule[Any, Any, Int]

A schedule that recurs forever, producing a count of repeats: 0, 1, 2, ...

final def fromFunction[A, B](f: (A) ⇒ B): Schedule[Any, A, B]

A schedule that recurs forever, mapping input values through the specified function.

final def getClass(): Class[_]

def hashCode(): Int

final def identity[A]: Schedule[Any, A, A]

A schedule that recurs forever, returning each input as the output.

final def isInstanceOf[T0]: Boolean

final def linear(base: Duration): Schedule[Clock, Any, Duration]

A schedule that always recurs, but will repeat on a linear time interval, given by base * n where n is the number of repetitions so far.

final def ne(arg0: AnyRef): Boolean

final val never: Schedule[Any, Any, Nothing]

A schedule that waits forever when updating or initializing.

final def notify(): Unit

final def notifyAll(): Unit

final val once: Schedule[Any, Any, Unit]

A schedule that executes once.

final def randomDelay(min: Duration, max: Duration): Schedule[Random with Clock, Any, Duration]

A schedule that sleeps for random duration that is uniformly distributed in the given range.

final def randomDelayNormal(mean: Duration, std: Duration): Schedule[Random with Clock, Any, Duration]

A schedule that sleeps for random duration that is normally distributed.

final def recurs(n: Int): Schedule[Any, Any, Int]

A schedule that recurs the specified number of times.

final def spaced(interval: Duration): Schedule[Clock, Any, Int]

A schedule that waits for the specified amount of time between each input.

|action|-----interval-----|action|-----interval-----|action|

final val stop: Schedule[Any, Any, Unit]

A schedule that always fails.

final def succeed[A](a: A): Schedule[Any, Any, A]

A schedule that recurs forever, returning the constant for every output.

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

final def tapInput[R, A](f: (A) ⇒ ZIO[R, Nothing, Unit]): Schedule[R, A, A]

A schedule that recurs forever, dumping input values to the specified sink, and returning those same values unmodified.

final def tapOutput[R, A](f: (A) ⇒ ZIO[R, Nothing, Unit]): Schedule[R, A, A]

A schedule that recurs forever, dumping output values to the specified sink, and returning those same values unmodified.

def toString(): String

final def unfold[A](a: ⇒ A)(f: (A) ⇒ A): Schedule[Any, Any, A]

A schedule that always recurs without delay, and computes the output through recured application of a function to a base value.

final def unfoldM[R, A](a: ZIO[R, Nothing, A])(f: (A) ⇒ ZIO[R, Nothing, A]): Schedule[R, Any, A]

A schedule that always recurs without delay, and computes the output through recured application of a function to a base value.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def succeedLazy[A](a: ⇒ A): Schedule[Any, Any, A]