Schedule

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. object Decision extends Serializable

   

5. final def apply[S, A, B](initial0: IO[Nothing, S], update0: (A, S) ⇒ IO[Nothing, Decision[S, B]]): Schedule[A, B]

   

6. final def asInstanceOf[T0]: T0

   

   Definition Classes

   Any

7. def clone(): AnyRef

   

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( ... )

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

   

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

9. final def delayed[A](s: Schedule[A, Duration]): Schedule[A, Duration]

   

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

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

    

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

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

    

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

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

    

    A schedule that will recur until the specified duration elapses.

13. final val elapsed: Schedule[Any, Duration]

    

    A schedule that recurs forever, and computes the time since the beginning.

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

    

    Definition Classes

    AnyRef

15. def equals(arg0: Any): Boolean

    

    Definition Classes

    AnyRef → Any

16. 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.

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

    

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

18. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

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

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

    

    A schedule that recurs on a fixed interval.

    A schedule that recurs on a fixed interval. Returns the amount of time since the schedule began.

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

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

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

    

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

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

    

    Definition Classes

    AnyRef → Any

22. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

23. final def identity[A]: Schedule[A, A]

    

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

24. final def isInstanceOf[T0]: Boolean

    

    Definition Classes

    Any

25. final def lift[A, B](f: (A) ⇒ B): Schedule[A, B]

    

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

26. final def logInput[A](f: (A) ⇒ IO[Nothing, Unit]): Schedule[A, A]

    

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

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

    

    Definition Classes

    AnyRef

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

    

    A schedule that never executes.

    A schedule that never executes. Note that negating this schedule does not produce a schedule that executes.

29. final def notify(): Unit

    

    Definition Classes

    AnyRef

30. final def notifyAll(): Unit

    

    Definition Classes

    AnyRef

31. final def once: Schedule[Any, Unit]

    

    A schedule that executes once.

32. final def point[A](a: ⇒ A): Schedule[Any, A]

    

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

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

    

    A schedule that recurs the specified number of times, producing a count of inputs.

34. final def spaced(interval: Duration): Schedule[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|
    

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

    

    Definition Classes

    AnyRef

36. def toString(): String

    

    Definition Classes

    AnyRef → Any

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

    

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

38. final def wait(): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )