Value Members

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

   Definition Classes

   AnyRef → Any

2.  final def ##(): Int

   Definition Classes

   AnyRef → Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

4.  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]
5.  final def asInstanceOf[T0]: T0

   Definition Classes

   Any

6.  def clone(): AnyRef

   Attributes

   protected[lang]

   Definition Classes

   AnyRef

   Annotations

   @throws(classOf[java.lang.CloneNotSupportedException]) @native()

7.  def collectAll[A]: Schedule[Any, A, List[A]]

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

8.  def collectUntil[A](f: (A) => Boolean): Schedule[Any, A, List[A]]

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

9.  def collectUntilM[A](f: (A) => UIO[Boolean]): Schedule[Any, A, List[A]]

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

10.  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.

11.  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.

12.  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.

13.  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.

14.  def doUntil[A](f: (A) => Boolean): Schedule[Any, A, A]

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

15.  def doUntilEquals[A](a: => A): Schedule[Any, A, A]

    A schedule that recurs for until the predicate is equal.

16.  def doUntilM[A](f: (A) => UIO[Boolean]): Schedule[Any, A, A]

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

17.  def doWhile[A](f: (A) => Boolean): Schedule[Any, A, A]

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

18.  def doWhileEquals[A](a: => A): Schedule[Any, A, A]

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

19.  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.

20.  def duration(duration: Duration): Schedule[Clock, Any, Duration]

    A schedule that will recur until the specified duration elapses.

    A schedule that will recur until the specified duration elapses. Returns the total elapsed time.

21.  val elapsed: Schedule[Clock, Any, Duration]

    A schedule that recurs forever without delay.

    A schedule that recurs forever without delay. Returns the elapsed time since the schedule began.

22.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

23.  def equals(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef → Any

24.  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.

    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. Returns the current duration between recurrences.

25.  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).

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

26.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.Throwable])

27.  def fixed(interval: Duration): Schedule[Clock, Any, Int]

    A schedule that recurs on a fixed interval.

    A schedule that recurs on a fixed interval. Returns the number of repetitions of the schedule so far.

    If the action run between updates takes longer than the interval, then the action will be run immediately, but re-runs will not "pile up".

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

28.  val forever: Schedule[Any, Any, Int]

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

29.  def fromDuration(duration: Duration): Schedule[Clock, Any, Duration]

    A schedule that recurs once with the specified delay.

30.  def fromDurations(duration: Duration, durations: Duration*): Schedule[Clock, Any, Duration]

    A schedule that recurs once for each of the specified durations, delaying each time for the length of the specified duration.

    A schedule that recurs once for each of the specified durations, delaying each time for the length of the specified duration. Returns the length of the current duration between recurrences.

31.  def fromFunction[A, B](f: (A) => B): Schedule[Any, A, B]

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

32.  final def getClass(): Class[_ <: AnyRef]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

33.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

34.  def identity[A]: Schedule[Any, A, A]

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

35.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

36.  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.

    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. Returns the current duration between recurrences.

37.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

38.  val never: Schedule[Any, Any, Nothing]

    A schedule that waits forever when updating or initializing.

39.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

40.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

41.  val once: Schedule[Any, Any, Unit]

    A schedule that executes once.

42.  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.

    A schedule that sleeps for random duration that is uniformly distributed in the given range. The schedules output is the duration it has slept on the last update, or 0 if it hasn't updated yet.

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

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

    A schedule that sleeps for random duration that is normally distributed. The schedules output is the duration it has slept on the last update, or 0 if it hasn't updated yet.

44.  def recurs(n: Int): Schedule[Any, Any, Int]

    A schedule that recurs the specified number of times.

    A schedule that recurs the specified number of times. Returns the number of repetitions so far.

    If 0 or negative numbers are given, the operation is not repeated at all so that in (op: IO[E, A]).repeat(Schedule.recurs(0)) , op is only done once and repeated 0 times.

45.  def spaced(interval: Duration): Schedule[Clock, Any, Int]

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

    A schedule that waits for the specified amount of time between each input. Returns the number of inputs so far.

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

46.  val stop: Schedule[Any, Any, Unit]

    A schedule that always fails.

47.  def succeed[A](a: A): Schedule[Any, Any, A]

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

48.  final def synchronized[T0](arg0: => T0): T0

    Definition Classes

    AnyRef

49.  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.

50.  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.

51.  def toString(): String

    Definition Classes

    AnyRef → Any

52.  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.

53.  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.

54.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException])

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

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException])

56.  final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException]) @native()