zio-interop-cats/zio.interop/Schedule

Schedule

sealed abstract class Schedule[F[_], -In, +Out]
See also:

zio.ZSchedule

Companion:
object
class Object
trait Matchable
class Any
Schedule[F, In, Out]

Type members

Types

type State

Value members

Concrete methods

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

zio.ZSchedule.&&

def ***[In2, Out2](that: Schedule[F, In2, Out2]): WithState[F, (State, State), (In, In2), (Out, Out2)]
See also:

zio.ZSchedule.***

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

zio.ZSchedule.*>

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

zio.ZSchedule.++

def +++[In2, Out2](that: Schedule[F, In2, Out2]): WithState[F, (State, State), Either[In, In2], Either[Out, Out2]]
See also:

zio.ZSchedule.+++

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

zio.ZSchedule.<*

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

zio.ZSchedule.<*>

def <<<[In2](that: Schedule[F, In2, In]): WithState[F, (State, State), In2, Out]
See also:

zio.ZSchedule.<<<

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

zio.ZSchedule.<||>

def >>>[Out2](that: Schedule[F, Out, Out2]): WithState[F, (State, State), In, Out2]
See also:

zio.ZSchedule.>>>

def addDelay(f: Out => Duration)(implicit trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.addDelay

def addDelayM(f: Out => F[Duration])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.addDelayM

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

zio.ZSchedule.andThen

def andThenEither[In1 <: In, Out2](that: Schedule[F, In1, Out2]): WithState[F, (State, State, Boolean), In1, Either[Out, Out2]]
See also:

zio.ZSchedule.andThenEither

def as[Out2](out2: => Out2)(implicit trace: Trace): WithState[F, State, In, Out2]
See also:

zio.ZSchedule.as

def check[In11 <: In](test: (In11, Out) => Boolean)(implicit trace: Trace): WithState[F, State, In11, Out]
See also:

zio.ZSchedule.check

def checkM[In1 <: In](test: (In1, Out) => F[Boolean])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In1, Out]
See also:

zio.ZSchedule.checkM

def collectAll[Out1 >: Out](implicit trace: Trace): WithState[F, (State, Chunk[Out1]), In, List[Out1]]
See also:

zio.ZSchedule.collectAll

def compose[In2](that: Schedule[F, In2, In]): WithState[F, (State, State), In2, Out]
See also:

zio.ZSchedule.compose

def contramap[In2](f: In2 => In)(implicit trace: Trace): WithState[F, State, In2, Out]
See also:

zio.ZSchedule.contramap

def delayed(f: Duration => Duration)(implicit trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.delayed

def delayedM(f: Duration => F[Duration])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.delayedM

def dimap[In2, Out2](f: In2 => In, g: Out => Out2)(implicit trace: Trace): WithState[F, State, In2, Out2]
See also:

zio.ZSchedule.dimap

def driver(implicit R: Runtime[Any], F: LiftIO[F], trace: Trace): F[Driver[F, State, In, Out]]
See also:

zio.ZSchedule.driver

def either[In1 <: In, Out2](that: Schedule[F, In1, Out2]): WithState[F, (State, State), In1, (Out, Out2)]
See also:

zio.ZSchedule.either

def eitherWith[In1 <: In, Out2, Out3](that: Schedule[F, In1, Out2])(f: (Out, Out2) => Out3)(implicit trace: Trace): WithState[F, (State, State), In1, Out3]
See also:

zio.ZSchedule.eitherWith

def ensuring(finalizer: F[Any])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.ensuring

def first[X]: WithState[F, (State, Unit), (In, X), (Out, X)]
See also:

zio.ZSchedule.first

def fold[Z](z: Z)(f: (Z, Out) => Z)(implicit trace: Trace): WithState[F, (State, Z), In, Z]
See also:

zio.ZSchedule.fold

def foldM[Z](z: Z)(f: (Z, Out) => F[Z])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, (State, Z), In, Z]
See also:

zio.ZSchedule.foldM

def forever: WithState[F, State, In, Out]
See also:

zio.ZSchedule.forever

def intersectWith[In1 <: In, Out2](that: Schedule[F, In1, Out2])(f: (Intervals, Intervals) => Intervals)(implicit zippable: Zippable[Out, Out2]): WithState[F, (State, State), In1, Out]
See also:

zio.ZSchedule.intersectWith

def jittered(implicit trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.jittered

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

zio.ZSchedule.jittered

def left[X]: WithState[F, (State, Unit), Either[In, X], Either[Out, X]]
See also:

zio.ZSchedule.left

def map[Out2](f: Out => Out2)(implicit trace: Trace): WithState[F, State, In, Out2]
See also:

zio.ZSchedule.map

def mapM[Out2](f: Out => F[Out2])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In, Out2]
See also:

zio.ZSchedule.mapM

def modifyDelay(f: (Out, Duration) => Duration): WithState[F, State, In, Out]
See also:

zio.ZSchedule.modifyDelay

def modifyDelayM(f: (Out, Duration) => F[Duration])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.modifyDelayM

def repetitions(implicit trace: Trace): WithState[F, (State, Long), In, Long]
See also:

zio.ZSchedule.repetitions

def resetAfter(duration: Duration)(implicit trace: Trace): WithState[F, (State, Option[OffsetDateTime]), In, Out]
See also:

zio.ZSchedule.resetAfter

def resetWhen(f: Out => Boolean): WithState[F, State, In, Out]
See also:

zio.ZSchedule.resetWhen

def right[X]: WithState[F, (Unit, State), Either[X, In], Either[X, Out]]
See also:

zio.ZSchedule.right

def run(now: OffsetDateTime, input: Iterable[In])(implicit R: Runtime[Any], F: LiftIO[F], trace: Trace): F[List[Out]]
See also:

zio.ZSchedule.run

def second[X]: WithState[F, (Unit, State), (X, In), (X, Out)]
See also:

zio.ZSchedule.second

def tapInput[In1 <: In](f: In1 => F[Any])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In1, Out]
See also:

zio.ZSchedule.tapInput

def tapOutput(f: Out => F[Any])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.tapOutput

def unionWith[In1 <: In, Out2](that: Schedule[F, In1, Out2])(f: (Intervals, Intervals) => Intervals)(implicit zippable: Zippable[Out, Out2]): WithState[F, (State, State), In1, Out]
See also:

zio.ZSchedule.unionWith

def unit(implicit trace: Trace): WithState[F, State, In, Unit]
See also:

zio.ZSchedule.unit

def untilInput[In1 <: In](f: In1 => Boolean)(implicit trace: Trace): WithState[F, State, In1, Out]
See also:

zio.ZSchedule.untilInput

def untilInputM[In1 <: In](f: In1 => F[Boolean])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In1, Out]
See also:

zio.ZSchedule.untilInputM

def untilOutput(f: Out => Boolean)(implicit trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.untilOutput

def untilOutputM(f: Out => F[Boolean])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.untilOutputM

def whileInput[In1 <: In](f: In1 => Boolean)(implicit trace: Trace): WithState[F, State, In1, Out]
See also:

zio.ZSchedule.whileInput

def whileInputM[In1 <: In](f: In1 => F[Boolean])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In1, Out]
See also:

zio.ZSchedule.whileInputM

def whileOutput(f: Out => Boolean)(implicit trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.whileOutput

def whileOutputM(f: Out => F[Boolean])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, State, In, Out]
See also:

zio.ZSchedule.whileOutputM

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

zio.ZSchedule.zip

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

zio.ZSchedule.zipLeft

def zipRight[In1 <: In, Out2](that: Schedule[F, In1, Out2])(implicit trace: Trace): WithState[F, (State, State), In1, Out2]
See also:

zio.ZSchedule.zipRight

def zipWith[In1 <: In, Out2, Out3](that: Schedule[F, In1, Out2])(f: (Out, Out2) => Out3)(implicit trace: Trace): WithState[F, (State, State), In1, Out3]
See also:

zio.ZSchedule.zipWith

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

zio.ZSchedule.||

def |||[Out1 >: Out, In2](that: Schedule[F, In2, Out1])(implicit trace: Trace): WithState[F, (State, State), Either[In, In2], Out1]
See also:

zio.ZSchedule.|||