Schedule

abstract def initial: State

abstract def step(now: OffsetDateTime, in: In, state: State)(implicit trace: Trace): ZIO[Env, Nothing, (State, Out, Decision)]

final def !=(arg0: Any): Boolean

final def ##(): Int

def &&[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]

Returns a new schedule that performs a geometric intersection on the intervals defined by both schedules.

def ***[Env1 <: Env, In2, Out2](that: Schedule[Env1, In2, Out2]): WithState[(State, State), Env1, (In, In2), (Out, Out2)]

Returns a new schedule that has both the inputs and outputs of this and the specified schedule.

def *>[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: Trace): WithState[(State, State), Env1, In1, Out2]

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

def ++[Env1 <: Env, In1 <: In, Out2 >: Out](that: Schedule[Env1, In1, Out2])(implicit trace: Trace): WithState[(State, State, Boolean), Env1, In1, Out2]

A symbolic alias for andThen.

def +++[Env1 <: Env, In2, Out2](that: Schedule[Env1, In2, Out2]): WithState[(State, State), Env1, Either[In, In2], Either[Out, Out2]]

Returns a new schedule that allows choosing between feeding inputs to this schedule, or feeding inputs to the specified schedule.

def <*[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: Trace): WithState[(State, State), Env1, In1, Out]

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

def <*>[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]

An operator alias for zip.

def <<<[Env1 <: Env, In2](that: Schedule[Env1, In2, In]): WithState[(State, State), Env1, In2, Out]

A backwards version of >>>.

def <||>[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2]): WithState[(State, State, Boolean), Env1, In1, Either[Out, Out2]]

Operator alias for andThenEither.

final def ==(arg0: Any): Boolean

def >>>[Env1 <: Env, Out2](that: Schedule[Env1, Out, Out2]): WithState[(State, State), Env1, In, Out2]

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

def addDelay(f: (Out) ⇒ zio.Duration)(implicit trace: Trace): WithState[State, Env, In, Out]

Returns a new schedule with the given delay added to every interval defined by this schedule.

def addDelayZIO[Env1 <: Env](f: (Out) ⇒ URIO[Env1, zio.Duration])(implicit trace: Trace): WithState[State, Env1, In, Out]

Returns a new schedule with the given effectfully computed delay added to every interval defined by this schedule.

def andThen[Env1 <: Env, In1 <: In, Out2 >: Out](that: Schedule[Env1, In1, Out2])(implicit trace: Trace): WithState[(State, State, Boolean), Env1, In1, Out2]

The same as andThenEither, but merges the output.

def andThenEither[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2]): WithState[(State, State, Boolean), Env1, In1, Either[Out, Out2]]

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

def as[Out2](out2: ⇒ Out2)(implicit trace: Trace): WithState[State, Env, In, Out2]

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

final def asInstanceOf[T0]: T0

def check[In1 <: In](test: (In1, Out) ⇒ Boolean)(implicit trace: Trace): WithState[State, Env, In1, Out]

Returns a new schedule that passes each input and output of this schedule to the specified function, and then determines whether or not to continue based on the return value of the function.

def checkZIO[Env1 <: Env, In1 <: In](test: (In1, Out) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In1, Out]

Returns a new schedule that passes each input and output of this schedule to the specified function, and then determines whether or not to continue based on the return value of the function.

def clone(): AnyRef

def collectAll[Out1 >: Out](implicit trace: Trace): WithState[(State, Chunk[Out1]), Env, In, Chunk[Out1]]

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

def collectUntil[Out1 >: Out](f: (Out) ⇒ Boolean)(implicit trace: Trace): WithState[(State, Chunk[Out1]), Env, In, Chunk[Out1]]

Returns a new schedule that collects the outputs of this one into a list until the condition f fails.

def collectUntilZIO[Env1 <: Env, Out1 >: Out](f: (Out) ⇒ URIO[Env1, Boolean])(implicit trace: Trace): WithState[(State, Chunk[Out1]), Env1, In, Chunk[Out1]]

Returns a new schedule that collects the outputs of this one into a list until the effectual condition f fails.

def collectWhile[Out1 >: Out](f: (Out) ⇒ Boolean)(implicit trace: Trace): WithState[(State, Chunk[Out1]), Env, In, Chunk[Out1]]

Returns a new schedule that collects the outputs of this one into a list as long as the condition f holds.

def collectWhileZIO[Env1 <: Env, Out1 >: Out](f: (Out) ⇒ URIO[Env1, Boolean])(implicit trace: Trace): WithState[(State, Chunk[Out1]), Env1, In, Chunk[Out1]]

Returns a new schedule that collects the outputs of this one into a list as long as the effectual condition f holds.

def compose[Env1 <: Env, In2](that: Schedule[Env1, In2, In]): WithState[(State, State), Env1, In2, Out]

A named alias for <<<.

def contramap[Env1 <: Env, In2](f: (In2) ⇒ In)(implicit trace: Trace): WithState[State, Env, In2, Out]

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

def contramapZIO[Env1 <: Env, In2](f: (In2) ⇒ URIO[Env1, In]): WithState[State, Env1, In2, Out]

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

def delayed(f: (zio.Duration) ⇒ zio.Duration)(implicit trace: Trace): WithState[State, Env, In, Out]

Returns a new schedule with the specified effectfully computed delay added before the start of each interval produced by this schedule.

def delayedZIO[Env1 <: Env](f: (zio.Duration) ⇒ URIO[Env1, zio.Duration]): WithState[State, Env1, In, Out]

Returns a new schedule with the specified effectfully computed delay added before the start of each interval produced by this schedule.

def delays: WithState[State, Env, In, zio.Duration]

Returns a new schedule that outputs the delay between each occurence.

def dimap[In2, Out2](f: (In2) ⇒ In, g: (Out) ⇒ Out2)(implicit trace: Trace): WithState[State, Env, In2, Out2]

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

def dimapZIO[Env1 <: Env, In2, Out2](f: (In2) ⇒ URIO[Env1, In], g: (Out) ⇒ URIO[Env1, Out2]): WithState[State, Env1, In2, Out2]

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

def driver(implicit trace: Trace): UIO[Driver[State, Env, In, Out]]

Returns a driver that can be used to step the schedule, appropriately handling sleeping.

def either[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2]): WithState[(State, State), Env1, In1, (Out, Out2)]

A named alias for ||.

def eitherWith[Env1 <: Env, In1 <: In, Out2, Out3](that: Schedule[Env1, In1, Out2])(f: (Out, Out2) ⇒ Out3)(implicit trace: Trace): WithState[(State, State), Env1, In1, Out3]

The same as either followed by map.

def ensuring(finalizer: UIO[Any]): WithState[State, Env, In, Out]

Returns a new schedule that will run the specified finalizer as soon as the schedule is complete.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def first[X]: WithState[(State, Unit), Env, (In, X), (Out, X)]

Returns a new schedule that packs the input and output of this schedule into the first element of a tuple.

def fold[Z](z: Z)(f: (Z, Out) ⇒ Z)(implicit trace: Trace): WithState[(State, Z), Env, In, Z]

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

def foldZIO[Env1 <: Env, Z](z: Z)(f: (Z, Out) ⇒ URIO[Env1, Z]): WithState[(State, Z), Env1, In, Z]

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

def forever: WithState[State, Env, In, Out]

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

final def getClass(): Class[_]

def hashCode(): Int

def intersectWith[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(f: (Intervals, Intervals) ⇒ Intervals)(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]

Returns a new schedule that combines this schedule with the specified schedule, continuing as long as both schedules want to continue and merging the next intervals according to the specified merge function.

final def isInstanceOf[T0]: Boolean

def jittered(min: Double, max: Double)(implicit trace: Trace): WithState[State, Env, In, Out]

Returns a new schedule that randomly modifies the size of the intervals of this schedule.

def jittered(implicit trace: Trace): WithState[State, Env, In, Out]

Returns a new schedule that randomly modifies the size of the intervals of this schedule.

def left[X]: WithState[(State, Unit), Env, Either[In, X], Either[Out, X]]

Returns a new schedule that makes this schedule available on the Left side of an Either input, allowing propagating some type X through this channel on demand.

def map[Out2](f: (Out) ⇒ Out2)(implicit trace: Trace): WithState[State, Env, In, Out2]

Returns a new schedule that maps the output of this schedule through the specified function.

def mapZIO[Env1 <: Env, Out2](f: (Out) ⇒ URIO[Env1, Out2]): WithState[State, Env1, In, Out2]

Returns a new schedule that maps the output of this schedule through the specified effectful function.

def modifyDelay(f: (Out, zio.Duration) ⇒ zio.Duration): WithState[State, Env, In, Out]

Returns a new schedule that modifies the delay using the specified function.

def modifyDelayZIO[Env1 <: Env](f: (Out, zio.Duration) ⇒ URIO[Env1, zio.Duration]): WithState[State, Env1, In, Out]

Returns a new schedule that modifies the delay using the specified effectual function.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onDecision[Env1 <: Env](f: (State, Out, Decision) ⇒ URIO[Env1, Any]): WithState[State, Env1, In, Out]

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

def passthrough[In1 <: In](implicit trace: Trace): WithState[State, Env, In1, In1]

Returns a new schedule that passes through the inputs of this schedule.

def provideEnvironment(env: ZEnvironment[Env]): WithState[State, Any, In, Out]

Returns a new schedule with its environment provided to it, so the resulting schedule does not require any environment.

def provideSomeEnvironment[Env2](f: (ZEnvironment[Env2]) ⇒ ZEnvironment[Env]): WithState[State, Env2, In, Out]

Transforms the environment being provided to this schedule with the specified function.

def reconsider[Out2](f: (State, Out, Decision) ⇒ Either[Out2, (Out2, Interval)])(implicit trace: Trace): WithState[State, Env, In, Out2]

Returns a new schedule that reconsiders every decision made by this schedule, possibly modifying the next interval and the output type in the process.

def reconsiderZIO[Env1 <: Env, In1 <: In, Out2](f: (State, Out, Decision) ⇒ URIO[Env1, Either[Out2, (Out2, Interval)]]): WithState[State, Env1, In1, Out2]

Returns a new schedule that effectfully reconsiders every decision made by this schedule, possibly modifying the next interval and the output type in the process.

def repetitions(implicit trace: Trace): WithState[(State, Long), Env, In, Long]

Returns a new schedule that outputs the number of repetitions of this one.

final def resetAfter(duration: zio.Duration)(implicit trace: Trace): WithState[(State, Option[OffsetDateTime]), Env, In, Out]

Return a new schedule that automatically resets the schedule to its initial state after some time of inactivity defined by duration.

final def resetWhen(f: (Out) ⇒ Boolean): WithState[State, Env, In, Out]

Resets the schedule when the specified predicate on the schedule output evaluates to true.

def right[X]: WithState[(Unit, State), Env, Either[X, In], Either[X, Out]]

Returns a new schedule that makes this schedule available on the Right side of an Either input, allowing propagating some type X through this channel on demand.

def run(now: OffsetDateTime, input: Iterable[In])(implicit trace: Trace): URIO[Env, Chunk[Out]]

Runs a schedule using the provided inputs, and collects all outputs.

def second[X]: WithState[(Unit, State), Env, (X, In), (X, Out)]

Returns a new schedule that packs the input and output of this schedule into the second element of a tuple.

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

def tapInput[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Any]): WithState[State, Env1, In1, Out]

Returns a new schedule that effectfully processes every input to this schedule.

def tapOutput[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Any]): WithState[State, Env1, In, Out]

Returns a new schedule that effectfully processes every output from this schedule.

def toString(): String

def unionWith[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(f: (Intervals, Intervals) ⇒ Intervals)(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]

Returns a new schedule that combines this schedule with the specified schedule, continuing as long as either schedule wants to continue and merging the next intervals according to the specified merge function.

def unit(implicit trace: Trace): WithState[State, Env, In, Unit]

Returns a new schedule that maps the output of this schedule to unit.

def untilInput[In1 <: In](f: (In1) ⇒ Boolean)(implicit trace: Trace): WithState[State, Env, In1, Out]

Returns a new schedule that continues until the specified predicate on the input evaluates to true.

def untilInputZIO[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Boolean])(implicit trace: Trace): WithState[State, Env1, In1, Out]

Returns a new schedule that continues until the specified effectful predicate on the input evaluates to true.

def untilOutput(f: (Out) ⇒ Boolean)(implicit trace: Trace): WithState[State, Env, In, Out]

Returns a new schedule that continues until the specified predicate on the output evaluates to true.

def untilOutputZIO[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Boolean])(implicit trace: Trace): WithState[State, Env1, In, Out]

Returns a new schedule that continues until the specified effectful predicate on the output evaluates to true.

def upTo(duration: zio.Duration)(implicit trace: Trace): WithState[(State, Option[OffsetDateTime]), Env, In, Out]

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 whileInput[In1 <: In](f: (In1) ⇒ Boolean)(implicit trace: Trace): WithState[State, Env, In1, Out]

Returns a new schedule that continues for as long the specified predicate on the input evaluates to true.

def whileInputZIO[Env1 <: Env, In1 <: In](f: (In1) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In1, Out]

Returns a new schedule that continues for as long the specified effectful predicate on the input evaluates to true.

def whileOutput(f: (Out) ⇒ Boolean)(implicit trace: Trace): WithState[State, Env, In, Out]

Returns a new schedule that continues for as long the specified predicate on the output evaluates to true.

def whileOutputZIO[Env1 <: Env](f: (Out) ⇒ URIO[Env1, Boolean]): WithState[State, Env1, In, Out]

Returns a new schedule that continues for as long the specified effectful predicate on the output evaluates to true.

def zip[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]

A named method for &&.

def zipLeft[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: Trace): WithState[(State, State), Env1, In1, Out]

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

def zipRight[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit trace: Trace): WithState[(State, State), Env1, In1, Out2]

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

def zipWith[Env1 <: Env, In1 <: In, Out2, Out3](that: Schedule[Env1, In1, Out2])(f: (Out, Out2) ⇒ Out3)(implicit trace: Trace): WithState[(State, State), Env1, In1, Out3]

Equivalent to zip followed by map.

def ||[Env1 <: Env, In1 <: In, Out2](that: Schedule[Env1, In1, Out2])(implicit zippable: Zippable[Out, Out2]): WithState[(State, State), Env1, In1, Out]

Returns a new schedule that performs a geometric union on the intervals defined by both schedules.

def |||[Env1 <: Env, Out1 >: Out, In2](that: Schedule[Env1, In2, Out1])(implicit trace: Trace): WithState[(State, State), Env1, Either[In, In2], Out1]

Returns a new schedule that chooses between two schedules with a common output.