Schedule_Functions

implicit abstract val ConformsAnyProof: ConformsR[Any]

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, Decision[S, B]])(implicit arg0: ConformsR[R]): ZSchedule[R, A, B]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def collect[A]: Schedule[A, List[A]]

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

final val decision: Schedule[Any, Boolean]

A schedule that will recur forever with no delay, returning the decision from the steps.

final val delay: Schedule[Any, Duration]

A schedule that will recur forever with no delay, returning the duration between steps.

final def delayed[R, A](s: ZSchedule[R, A, Duration])(implicit arg0: ConformsR[R]): ZSchedule[R, A, Duration]

A new schedule derived from the specified schedule which adds the delay specified as output to the existing duration.

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

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

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

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def exponential(base: Duration, factor: Double = 2.0): Schedule[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[Any, Duration]

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

def finalize(): Unit

final val forever: Schedule[Any, Int]

A schedule that recurs forever, producing a count of inputs.

final def fromFunction[A, B](f: (A) ⇒ B): Schedule[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[A, A]

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

final def isInstanceOf[T0]: Boolean

final def linear(base: Duration): Schedule[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 logInput[R, A](f: (A) ⇒ ZIO[R, Nothing, Unit])(implicit arg0: ConformsR[R]): ZSchedule[R, A, A]

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

final def ne(arg0: AnyRef): Boolean

final val never: Schedule[Any, Nothing]

A schedule that never executes.

final def notify(): Unit

final def notifyAll(): Unit

final val once: Schedule[Any, Unit]

A schedule that executes once.

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

A schedule that recurs the specified number of times.

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

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

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

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

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

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

A schedule that recurs forever, returning the constant for every output (by-name version).

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

def toString(): String

final def unfold[A](a: ⇒ A)(f: (A) ⇒ A): Schedule[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])(implicit arg0: ConformsR[R]): ZSchedule[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