Schedule

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Decision

object Interval extends (OffsetDateTime, OffsetDateTime) ⇒ Interval

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collectAll[A](implicit trace: ZTraceElement): WithState[(Unit, Chunk[A]), Any, A, Chunk[A]]

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

def collectUntil[A](f: (A) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[(Unit, Chunk[A]), Any, A, Chunk[A]]

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

def collectUntilZIO[Env, A](f: (A) ⇒ URIO[Env, Boolean])(implicit trace: ZTraceElement): WithState[(Unit, Chunk[A]), Env, A, Chunk[A]]

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

def collectWhile[A](f: (A) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[(Unit, Chunk[A]), Any, A, Chunk[A]]

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

def collectWhileZIO[Env, A](f: (A) ⇒ URIO[Env, Boolean])(implicit trace: ZTraceElement): WithState[(Unit, Chunk[A]), Env, A, Chunk[A]]

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

val count: WithState[Long, Any, Any, Long]

A schedule that always recurs, which counts the number of recurrences.

def dayOfMonth(day: Int)(implicit trace: ZTraceElement): WithState[Long, Any, Any, Long]

Cron-like schedule that recurs every specified day of month.

def dayOfWeek(day: Int)(implicit trace: ZTraceElement): WithState[Long, Any, Any, Long]

Cron-like schedule that recurs every specified day of each week.

def delayed[Env, In](schedule: Schedule[Env, In, zio.Duration])(implicit trace: ZTraceElement): WithState[State, Env, In, zio.Duration]

Takes a schedule that produces a delay, and returns a new schedule that uses this delay to further delay intervals in the resulting schedule.

def duration(duration: zio.Duration): WithState[Boolean, Any, Any, zio.Duration]

A schedule that can recur one time, the specified amount of time into the future.

val elapsed: WithState[Option[OffsetDateTime], Any, Any, zio.Duration]

A schedule that occurs everywhere, which returns the total elapsed duration since the first step.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exponential(base: zio.Duration, factor: Double = 2.0)(implicit trace: ZTraceElement): WithState[Long, Any, Any, zio.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.

def fibonacci(one: zio.Duration)(implicit trace: ZTraceElement): WithState[(zio.Duration, zio.Duration), Any, Any, zio.Duration]

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

def finalize(): Unit

def fixed(interval: zio.Duration): WithState[(Option[(Long, Long)], Long), Any, Any, Long]

A schedule that recurs on a fixed interval.

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

val forever: WithState[Long, Any, Any, Long]

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

def fromDuration(duration: zio.Duration): WithState[Boolean, Any, Any, zio.Duration]

A schedule that recurs once with the specified delay.

def fromDurations(duration: zio.Duration, durations: zio.Duration*): WithState[(::[zio.Duration], Boolean), Any, Any, zio.Duration]

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

def fromFunction[A, B](f: (A) ⇒ B)(implicit trace: ZTraceElement): WithState[Unit, Any, A, B]

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

final def getClass(): Class[_]

def hashCode(): Int

def hourOfDay(hour: Int)(implicit trace: ZTraceElement): WithState[Long, Any, Any, Long]

Cron-like schedule that recurs every specified hour of each day.

def identity[A]: WithState[Unit, Any, A, A]

A schedule that always recurs, which returns inputs as outputs.

final def isInstanceOf[T0]: Boolean

def linear(base: zio.Duration)(implicit trace: ZTraceElement): WithState[Long, Any, Any, zio.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.

def maxOffsetDateTime(l: OffsetDateTime, r: OffsetDateTime): OffsetDateTime

def minOffsetDateTime(l: OffsetDateTime, r: OffsetDateTime): OffsetDateTime

def minuteOfHour(minute: Int)(implicit trace: ZTraceElement): WithState[Long, Any, Any, Long]

Cron-like schedule that recurs every specified minute of each hour.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def once(implicit trace: ZTraceElement): WithState[Long, Any, Any, Unit]

A schedule that recurs one time.

def recurUntil[A, B](pf: PartialFunction[A, B])(implicit trace: ZTraceElement): WithState[Unit, 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.

def recurUntil[A](f: (A) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[Unit, Any, A, A]

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

def recurUntilEquals[A](a: ⇒ A)(implicit trace: ZTraceElement): WithState[Unit, Any, A, A]

A schedule that recurs for until the predicate is equal.

def recurUntilZIO[Env, A](f: (A) ⇒ URIO[Env, Boolean])(implicit trace: ZTraceElement): WithState[Unit, Env, A, A]

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

def recurWhile[A](f: (A) ⇒ Boolean)(implicit trace: ZTraceElement): WithState[Unit, Any, A, A]

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

def recurWhileEquals[A](a: ⇒ A)(implicit trace: ZTraceElement): WithState[Unit, Any, A, A]

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

def recurWhileZIO[Env, A](f: (A) ⇒ URIO[Env, Boolean]): WithState[Unit, Env, A, A]

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

def recurs(n: Int)(implicit trace: ZTraceElement): WithState[Long, Any, Any, Long]

A schedule spanning all time, which can be stepped only the specified number of times before it terminates.

def recurs(n: Long)(implicit trace: ZTraceElement): WithState[Long, Any, Any, Long]

A schedule spanning all time, which can be stepped only the specified number of times before it terminates.

def secondOfMinute(second0: ⇒ Int)(implicit trace: ZTraceElement): WithState[Long, Any, Any, Long]

Cron-like schedule that recurs every specified second of each minute.

def spaced(duration: zio.Duration)(implicit trace: ZTraceElement): WithState[Long, Any, Any, Long]

Returns a schedule that recurs continuously, each repetition spaced the specified duration from the last run.

def stop(implicit trace: ZTraceElement): WithState[Long, Any, Any, Unit]

A schedule that does not recur, it just stops.

def succeed[A](a: ⇒ A)(implicit trace: ZTraceElement): WithState[Long, Any, Any, A]

Returns a schedule that repeats one time, producing the specified constant value.

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

def toString(): String

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

Unfolds a schedule that repeats one time from the specified state and iterator.

def upTo(duration: zio.Duration)(implicit trace: ZTraceElement): WithState[Option[OffsetDateTime], Any, Any, zio.Duration]

A schedule that recurs during the given duration

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def windowed(interval: zio.Duration): WithState[(Option[Long], Long), Any, Any, Long]

A schedule that divides the timeline to interval-long windows, and sleeps until the nearest window boundary every time it recurs.

     10s        10s        10s       10s
|----------|----------|----------|----------|
|action------|sleep---|act|-sleep|action----|

def collectUntilM[Env, A](f: (A) ⇒ URIO[Env, Boolean])(implicit trace: ZTraceElement): WithState[(Unit, Chunk[A]), Env, A, Chunk[A]]

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

def collectWhileM[Env, A](f: (A) ⇒ URIO[Env, Boolean])(implicit trace: ZTraceElement): WithState[(Unit, Chunk[A]), Env, A, Chunk[A]]

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

def recurUntilM[Env, A](f: (A) ⇒ URIO[Env, Boolean])(implicit trace: ZTraceElement): WithState[Unit, Env, A, A]

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

def recurWhileM[Env, A](f: (A) ⇒ URIO[Env, Boolean]): WithState[Unit, Env, A, A]

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