zio-interop-cats/zio.interop/Schedule

Schedule

object Schedule
Companion:
class
class Object
trait Matchable
class Any

Type members

Classlikes

final class Driver[F[_], +State, -In, +Out]

Types

type WithState[F[_], State0, -In, +Out] = Schedule[F, In, Out] { type State = State0; }

Value members

Concrete methods

def collectAll[F[_], A](implicit trace: Trace): WithState[F, (Unit, Chunk[A]), A, List[A]]
See also:

zio.ZSchedule.collectAll

def collectUntil[F[_], A](f: A => Boolean)(implicit trace: Trace): WithState[F, (Unit, Chunk[A]), A, List[A]]
See also:

zio.ZSchedule.collectUntil

def collectUntilM[F[_], A](f: A => F[Boolean])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, (Unit, Chunk[A]), A, List[A]]
See also:

zio.ZSchedule.collectUntilM

def collectWhile[F[_], A](f: A => Boolean)(implicit trace: Trace): WithState[F, (Unit, Chunk[A]), A, List[A]]
See also:

zio.ZSchedule.collectWhile

def collectWhileM[F[_], A](f: A => F[Boolean])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, (Unit, Chunk[A]), A, List[A]]
See also:

zio.ZSchedule.collectWhileM

def count[F[_]]: WithState[F, Long, Any, Long]
See also:

zio.ZSchedule.count

def delayed[F[_], In, Out](schedule: Schedule[F, In, Duration])(implicit trace: Trace): WithState[F, State, In, Duration]
See also:

zio.ZSchedule.delayed

def duration[F[_]](duration: Duration): WithState[F, Boolean, Any, Duration]
See also:

zio.ZSchedule.duration

def elapsed[F[_]]: WithState[F, Option[OffsetDateTime], Any, Duration]
See also:

zio.ZSchedule.elapsed

def exponential[F[_]](base: Duration, factor: Double)(implicit trace: Trace): WithState[F, Long, Any, Duration]
See also:

zio.ZSchedule.exponential

def fibonacci[F[_]](one: Duration)(implicit trace: Trace): WithState[F, (Duration, Duration), Any, Duration]
See also:

zio.ZSchedule.fibonacci

def fixed[F[_]](interval: Duration): WithState[F, (Option[(Long, Long)], Long), Any, Long]
See also:

zio.ZSchedule.fixed

def forever[F[_]]: WithState[F, Long, Any, Long]
See also:

zio.ZSchedule.forever

def fromDuration[F[_]](duration: Duration): WithState[F, Boolean, Any, Duration]
See also:

zio.ZSchedule.fromDuration

def fromDurations[F[_]](duration: Duration, durations: Duration*): WithState[F, (::[Duration], Boolean), Any, Duration]
See also:

zio.ZSchedule.fromDurations

def fromFunction[F[_], A, B](f: A => B)(implicit trace: Trace): WithState[F, Unit, A, B]
See also:

zio.ZSchedule.fromFunction

def identity[F[_], A]: WithState[F, Unit, A, A]
See also:

zio.ZSchedule.v

def linear[F[_]](base: Duration)(implicit trace: Trace): WithState[F, Long, Any, Duration]
See also:

zio.ZSchedule.linear

def once[F[_]](implicit trace: Trace): WithState[F, Long, Any, Unit]
See also:

zio.ZSchedule.once

def recurUntil[F[_], A](f: A => Boolean)(implicit trace: Trace): WithState[F, Unit, A, A]
See also:

zio.ZSchedule.recurUntil

def recurUntil[F[_], A, B](pf: PartialFunction[A, B])(implicit trace: Trace): WithState[F, Unit, A, Option[B]]
See also:

zio.ZSchedule.recurUntil

def recurUntilEquals[F[_], A](a: => A)(implicit trace: Trace): WithState[F, Unit, A, A]
See also:

zio.ZSchedule.recurUntilEquals

def recurUntilM[F[_], A](f: A => F[Boolean])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, Unit, A, A]
See also:

zio.ZSchedule.recurUntilM

def recurWhile[F[_], A](f: A => Boolean)(implicit trace: Trace): WithState[F, Unit, A, A]
See also:

zio.ZSchedule.recurWhile

def recurWhileEquals[F[_], A](a: => A)(implicit trace: Trace): WithState[F, Unit, A, A]
See also:

zio.ZSchedule.recurWhileEquals

def recurWhileM[F[_], A](f: A => F[Boolean])(implicit R: Runtime[Any], F: Effect[F], trace: Trace): WithState[F, Unit, A, A]
See also:

zio.ZSchedule.recurWhileM

def recurs[F[_]](n: Long)(implicit trace: Trace): WithState[F, Long, Any, Long]
See also:

zio.ZSchedule.recurs

def recurs[F[_]](n: Int)(implicit trace: Trace): WithState[F, Long, Any, Long]
See also:

zio.ZSchedule.recurs

def spaced[F[_]](duration: Duration)(implicit trace: Trace): WithState[F, Long, Any, Long]
See also:

zio.ZSchedule.spaced

def stop[F[_]](implicit trace: Trace): WithState[F, Long, Any, Unit]
See also:

zio.ZSchedule.stop

def succeed[F[_], A](a: => A)(implicit trace: Trace): WithState[F, Long, Any, A]
See also:

zio.ZSchedule.succeed

def unfold[F[_], A](a: => A)(f: A => A): WithState[F, A, Any, A]
See also:

zio.ZSchedule.unfold

def windowed[F[_]](interval: Duration): WithState[F, (Option[Long], Long), Any, Long]
See also:

zio.ZSchedule.windowed