ZSchedule

abstract val initial: ZIO[R, Nothing, State]

The initial state of the schedule.

abstract val update: (A, State) ⇒ ZIO[R, Nothing, Decision[State, B]]

Updates the schedule based on a new input and the current state.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def &&[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C]): ZSchedule[R1, A1, (B, C)]

Returns a new schedule that continues only as long as both schedules continue, using the maximum of the delays of the two schedules.

final def ***[R1 <: R, C, D](that: ZSchedule[R1, C, D]): ZSchedule[R1, (A, C), (B, D)]

Split the input

final def *>[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C]): ZSchedule[R1, A1, C]

The same as &&, but ignores the left output.

final def +++[R1 <: R, C, D](that: ZSchedule[R1, C, D]): ZSchedule[R1, Either[A, C], Either[B, D]]

Chooses between two schedules with different outputs.

final def <*[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C]): ZSchedule[R1, A1, B]

The same as &&, but ignores the right output.

final def <*>[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C]): ZSchedule[R1, A1, (B, C)]

Returns a new schedule that continues only as long as both schedules continue, using the maximum of the delays of the two schedules.

final def <<<[R1 <: R, C](that: ZSchedule[R1, C, A]): ZSchedule[R1, C, B]

A backwards version of >>>.

final def ==(arg0: Any): Boolean

final def >>>[R1 <: R, C](that: ZSchedule[R1, B, C]): ZSchedule[R1, A, C]

Returns the composition of this schedule and the specified schedule, by piping the output of this one into the input of the other, and summing delays produced by both.

final def andThen[R1 <: R, A1 <: A, B1 >: B](that: ZSchedule[R1, A1, B1]): ZSchedule[R1, A1, B1]

The same as andThenEither, but merges the output.

final def andThenEither[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C]): ZSchedule[R1, A1, Either[B, C]]

Returns a new schedule that first executes this schedule to completion, and then executes the specified schedule to completion.

final def as[C](c: ⇒ C): ZSchedule[R, A, C]

Returns a new schedule that maps this schedule to a constant output.

final def asInstanceOf[T0]: T0

final def both[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C]): ZSchedule[R1, A1, (B, C)]

A named alias for &&.

final def bothWith[R1 <: R, A1 <: A, C, D](that: ZSchedule[R1, A1, C])(f: (B, C) ⇒ D): ZSchedule[R1, A1, D]

The same as both followed by map.

final def check[A1 <: A](test: (A1, B) ⇒ UIO[Boolean]): ZSchedule[R, A1, B]

Peeks at the state produced by this schedule, executes some action, and then continues the schedule or not based on the specified state predicate.

def clone(): AnyRef

final def collectAll: ZSchedule[R, A, List[B]]

Returns a new schedule that collects the outputs of this one into a list.

final def combineWith[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C])(g: (Boolean, Boolean) ⇒ Boolean, f: (Duration, Duration) ⇒ Duration): ZSchedule[R1, A1, (B, C)]

Creates a new schedule that outputs elements of both underlying schedules pair-wie.

final def compose[R1 <: R, C](that: ZSchedule[R1, C, A]): ZSchedule[R1, C, B]

An alias for <<<

final def contramap[A1](f: (A1) ⇒ A): ZSchedule[R, A1, B]

Returns a new schedule that deals with a narrower class of inputs than this schedule.

final def delayed(f: (Duration) ⇒ Duration): ZSchedule[R, A, B]

Returns a new schedule with the specified pure modification applied to each delay produced by this schedule.

final def dimap[A1, C](f: (A1) ⇒ A, g: (B) ⇒ C): ZSchedule[R, A1, C]

Returns a new schedule that contramaps the input and maps the output.

final def either[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C]): ZSchedule[R1, A1, (B, C)]

A named alias for ||.

final def eitherWith[R1 <: R, A1 <: A, C, D](that: ZSchedule[R1, A1, C])(f: (B, C) ⇒ D): ZSchedule[R1, A1, D]

The same as either followed by map.

final def ensuring(finalizer: UIO[_]): ZSchedule[R, A, B]

Runs the specified finalizer as soon as the schedule is complete.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def first[R1 <: R, C]: ZSchedule[R1, (A, C), (B, C)]

Puts this schedule into the first element of a tuple, and passes along another value unchanged as the second element of the tuple.

final def fold[Z](z: Z)(f: (Z, B) ⇒ Z): ZSchedule[R, A, Z]

Returns a new schedule that folds over the outputs of this one.

final def foldM[Z](z: UIO[Z])(f: (Z, B) ⇒ UIO[Z]): ZSchedule[R, A, Z]

Returns a new schedule that effectfully folds over the outputs of this one.

final def forever: ZSchedule[R, A, B]

Returns a new schedule that loops this one forever, resetting the state when this schedule is done.

final def getClass(): Class[_]

def hashCode(): Int

final def initialized[R1 <: R, A1 <: A](f: (ZIO[R1, Nothing, State]) ⇒ ZIO[R1, Nothing, State]): ZSchedule[R1, A1, B]

Returns a new schedule with the specified initial state transformed by the specified initial transformer.

final def isInstanceOf[T0]: Boolean

final def jittered(min: Double, max: Double): ZSchedule[R with Random, A, B]

Applies random jitter to the schedule bounded by the specified factors, with a given random generator.

final def jittered: ZSchedule[R with Random, A, B]

Applies random jitter to the schedule bounded by the factors 0.0 and 1.0.

final def left[C]: ZSchedule[R, Either[A, C], Either[B, C]]

Puts this schedule into the first element of a either, and passes along another value unchanged as the second element of the either.

final def logInput[R1 <: R, A1 <: A](f: (A1) ⇒ ZIO[R1, Nothing, Unit]): ZSchedule[R1, A1, B]

Sends every input value to the specified sink.

final def logOutput[R1 <: R](f: (B) ⇒ ZIO[R1, Nothing, Unit]): ZSchedule[R1, A, B]

Sends every output value to the specified sink.

final def map[A1 <: A, C](f: (B) ⇒ C): ZSchedule[R, A1, C]

Returns a new schedule that maps over the output of this one.

final def modifyDelay[R1 <: R](f: (B, Duration) ⇒ ZIO[R1, Nothing, Duration]): ZSchedule[R1, A, B]

Returns a new schedule with the specified effectful modification applied to each delay produced by this schedule.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def onDecision[A1 <: A](f: (A1, Decision[State, B]) ⇒ UIO[Unit]): ZSchedule[R, A1, B]

A new schedule that applies the current one but runs the specified effect for every decision of this schedule.

final def reconsider[A1 <: A, C](f: (A1, Decision[State, B]) ⇒ Decision[State, C]): ZSchedule[R, A1, C]

Returns a new schedule that reconsiders the decision made by this schedule.

final def reconsiderM[A1 <: A, C](f: (A1, Decision[State, B]) ⇒ UIO[Decision[State, C]]): ZSchedule[R, A1, C]

Returns a new schedule that effectfully reconsiders the decision made by this schedule.

final def right[C]: ZSchedule[R, Either[C, A], Either[C, B]]

Puts this schedule into the second element of a either, and passes along another value unchanged as the first element of the either.

final def run(as: Iterable[A]): ZIO[R, Nothing, List[(Duration, B)]]

Runs the schedule on the provided list of inputs, returning a list of durations and outputs.

final def second[C]: ZSchedule[R, (C, A), (C, B)]

Puts this schedule into the second element of a tuple, and passes along another value unchanged as the first element of the tuple.

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

def toString(): String

final def unary_!: ZSchedule[R, A, B]

Returns a new schedule that inverts the decision to continue.

final def unit: ZSchedule[R, A, Unit]

Returns a new schedule that maps this schedule to a Unit output.

final def untilInput[A1 <: A](f: (A1) ⇒ Boolean): ZSchedule[R, A1, B]

Returns a new schedule that continues the schedule only until the predicate is satisfied on the input of the schedule.

final def untilInputM[A1 <: A](f: (A1) ⇒ UIO[Boolean]): ZSchedule[R, A1, B]

Returns a new schedule that continues the schedule only until the effectful predicate is satisfied on the input of the schedule.

final def untilOutput(f: (B) ⇒ Boolean): ZSchedule[R, A, B]

Returns a new schedule that continues the schedule only until the predicate is satisfied on the output value of the schedule.

final def updated[R1 <: R, A1 <: A, B1](f: ((A, State) ⇒ ZIO[R, Nothing, Decision[State, B]]) ⇒ (A1, State) ⇒ ZIO[R1, Nothing, Decision[State, B1]]): ZSchedule[R1, A1, B1]

Returns a new schedule with the update function transformed by the specified update transformer.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def whileInput[A1 <: A](f: (A1) ⇒ Boolean): ZSchedule[R, A1, B]

Returns a new schedule that continues this schedule so long as the predicate is satisfied on the input of the schedule.

final def whileInputM[A1 <: A](f: (A1) ⇒ UIO[Boolean]): ZSchedule[R, A1, B]

Returns a new schedule that continues this schedule so long as the effectful predicate is satisfied on the input of the schedule.

final def whileOutput(f: (B) ⇒ Boolean): ZSchedule[R, A, B]

Returns a new schedule that continues this schedule so long as the predicate is satisfied on the output value of the schedule.

final def zip[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C]): ZSchedule[R1, A1, (B, C)]

Named alias for <*>.

final def zipLeft[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C]): ZSchedule[R1, A1, B]

Named alias for <*.

final def zipRight[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C]): ZSchedule[R1, A1, C]

Named alias for *>.

final def ||[R1 <: R, A1 <: A, C](that: ZSchedule[R1, A1, C]): ZSchedule[R1, A1, (B, C)]

Returns a new schedule that continues as long as either schedule continues, using the minimum of the delays of the two schedules.

final def |||[R1 <: R, B1 >: B, C](that: ZSchedule[R1, C, B1]): ZSchedule[R1, Either[A, C], B1]

Chooses between two schedules with a common output.

final def const[C](c: ⇒ C): ZSchedule[R, A, C]

final def void: ZSchedule[R, A, Unit]

Returns a new schedule that maps this schedule to a Unit output.