< Back

Packages

o

RIO

object RIO

Linear Supertypes

Ordering

Alphabetic
By Inheritance

Inherited

RIO
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def _1[R, A, B](implicit ev: <:<[R, (A, B)]): RIO[R, A]

See also
See zio.ZIO._1
final def _2[R, A, B](implicit ev: <:<[R, (A, B)]): RIO[R, B]

See also
See zio.ZIO._2
final def absolve[R, A](v: RIO[R, Either[Throwable, A]]): RIO[R, A]

See also
See zio.ZIO.absolve
final def access[R]: AccessPartiallyApplied[R]

See also
See zio.ZIO.access
final def accessM[R]: AccessMPartiallyApplied[R]

See also
See zio.ZIO.accessM
final def allowInterrupt: UIO[Unit]

See also
See zio.ZIO.allowInterrupt
def apply[A](a: ⇒ A): Task[A]

See also
See zio.ZIO.apply
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def bracket[R, A, B](acquire: RIO[R, A], release: (A) ⇒ ZIO[R, Nothing, _], use: (A) ⇒ RIO[R, B]): RIO[R, B]

See also
See bracket zio.ZIO
final def bracket[R, A](acquire: RIO[R, A]): BracketAcquire[R, Throwable, A]

See also
See bracket zio.ZIO
final def bracketExit[R, A, B](acquire: RIO[R, A], release: (A, Exit[Throwable, B]) ⇒ ZIO[R, Nothing, _], use: (A) ⇒ RIO[R, B]): RIO[R, B]

See also
See bracketExit zio.ZIO
final def bracketExit[R, A](acquire: RIO[R, A]): BracketExitAcquire[R, Throwable, A]

See also
See bracketExit zio.ZIO
final def checkInterruptible[R, A](f: (InterruptStatus) ⇒ RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.checkInterruptible
final def checkSupervised[R, A](f: (SuperviseStatus) ⇒ RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.checkSupervised
final def checkTraced[R, A](f: (TracingStatus) ⇒ RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.checkTraced
final def children: UIO[IndexedSeq[Fiber[_, _]]]

See also
See zio.ZIO.children
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@native() @throws( ... )
final def collectAll[R, A](in: Iterable[RIO[R, A]]): RIO[R, List[A]]

See also
See zio.ZIO.collectAll
final def collectAllPar[R, A](as: Iterable[RIO[R, A]]): RIO[R, List[A]]

See also
See zio.ZIO.collectAllPar
final def collectAllParN[R, A](n: Int)(as: Iterable[RIO[R, A]]): RIO[R, List[A]]

See also
See zio.ZIO.collectAllParN
final def descriptor: UIO[Descriptor]

See also
See zio.ZIO.descriptor
final def descriptorWith[R, A](f: (Descriptor) ⇒ RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.descriptorWith
final def die(t: Throwable): UIO[Nothing]

See also
See zio.ZIO.die
final def dieMessage(message: String): UIO[Nothing]

See also
See zio.ZIO.dieMessage
final def done[A](r: Exit[Throwable, A]): Task[A]

See also
See zio.ZIO.done
final def effect[A](effect: ⇒ A): Task[A]

See also
See zio.ZIO.effect
final def effectAsync[R, A](register: ((RIO[R, A]) ⇒ Unit) ⇒ Unit): RIO[R, A]

See also
See zio.ZIO.effectAsync
final def effectAsyncInterrupt[R, A](register: ((RIO[R, A]) ⇒ Unit) ⇒ Either[Canceler, RIO[R, A]]): RIO[R, A]

See also
See zio.ZIO.effectAsyncInterrupt
final def effectAsyncM[R, A](register: ((RIO[R, A]) ⇒ Unit) ⇒ ZIO[R, Nothing, _]): RIO[R, A]

See also
See zio.ZIO.effectAsyncM
final def effectAsyncMaybe[A](register: ((Task[A]) ⇒ Unit) ⇒ Option[Task[A]]): Task[A]

See also
See zio.ZIO.effectAsyncMaybe
final def effectSuspend[R, A](rio: ⇒ RIO[R, A]): RIO[R, A]
Returns a lazily constructed effect, whose construction may itself require effects.
Returns a lazily constructed effect, whose construction may itself require effects. When no environment is required (i.e., when R == Any) it is conceptually equivalent to flatten(effect(io)).
final def effectSuspendTotal[R, A](rio: ⇒ RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.effectSuspendTotal
final def effectSuspendTotalWith[R, A](p: (Platform) ⇒ RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.effectSuspendTotalWith
final def effectSuspendWith[R, A](p: (Platform) ⇒ RIO[R, A]): RIO[R, A]
Returns a lazily constructed effect, whose construction may itself require effects.
Returns a lazily constructed effect, whose construction may itself require effects. When no environment is required (i.e., when R == Any) it is conceptually equivalent to flatten(effect(io)).
final def effectTotal[A](effect: ⇒ A): UIO[A]

See also
See zio.ZIO.effectTotal
final def environment[R]: ZIO[R, Nothing, R]

See also
See zio.ZIO.environment
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def fail(error: Throwable): Task[Nothing]

See also
See zio.ZIO.fail
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def firstSuccessOf[R, A](rio: RIO[R, A], rest: Iterable[RIO[R, A]]): RIO[R, A]

See also
See zio.ZIO.firstSuccessOf
final def flatten[R, A](taskr: RIO[R, RIO[R, A]]): RIO[R, A]

See also
See zio.ZIO.flatten
final def foldLeft[R, S, A](in: Iterable[A])(zero: S)(f: (S, A) ⇒ RIO[R, S]): RIO[R, S]

See also
See zio.ZIO.foldLeft
final def foreach[R, A, B](in: Iterable[A])(f: (A) ⇒ RIO[R, B]): RIO[R, List[B]]

See also
See zio.ZIO.foreach
final def foreachPar[R, A, B](as: Iterable[A])(fn: (A) ⇒ RIO[R, B]): RIO[R, List[B]]

See also
See zio.ZIO.foreachPar
final def foreachParN[R, A, B](n: Int)(as: Iterable[A])(fn: (A) ⇒ RIO[R, B]): RIO[R, List[B]]

See also
See zio.ZIO.foreachParN
final def foreachParN_[R, A, B](n: Int)(as: Iterable[A])(f: (A) ⇒ RIO[R, _]): RIO[R, Unit]

See also
See zio.ZIO.foreachParN_
final def foreachPar_[R, A, B](as: Iterable[A])(f: (A) ⇒ RIO[R, _]): RIO[R, Unit]

See also
See zio.ZIO.foreachPar_
final def foreach_[R, A](as: Iterable[A])(f: (A) ⇒ RIO[R, _]): RIO[R, Unit]

See also
See zio.ZIO.foreach_
final def forkAll[R, A](as: Iterable[RIO[R, A]]): ZIO[R, Nothing, Fiber[Throwable, List[A]]]

See also
See zio.ZIO.forkAll
final def forkAll_[R, A](as: Iterable[RIO[R, A]]): ZIO[R, Nothing, Unit]

See also
See zio.ZIO.forkAll_
final def fromEither[A](v: ⇒ Either[Throwable, A]): Task[A]

See also
See zio.ZIO.fromEither
final def fromFiber[A](fiber: ⇒ Fiber[Throwable, A]): Task[A]

See also
See zio.ZIO.fromFiber
final def fromFiberM[A](fiber: Task[Fiber[Throwable, A]]): Task[A]

See also
See zio.ZIO.fromFiberM
final def fromFunction[R, A](f: (R) ⇒ A): ZIO[R, Nothing, A]

See also
See zio.ZIO.fromFunction
final def fromFunctionM[R, A](f: (R) ⇒ Task[A]): RIO[R, A]

See also
See zio.ZIO.fromFunctionM
final def fromFuture[A](make: (ExecutionContext) ⇒ Future[A]): Task[A]

See also
See zio.ZIO.fromFuture
final def fromTry[A](value: ⇒ Try[A]): Task[A]

See also
See zio.ZIO.fromTry
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
final def halt(cause: Cause[Throwable]): Task[Nothing]

See also
See zio.ZIO.halt
final def haltWith[R](function: (() ⇒ ZTrace) ⇒ Cause[Throwable]): RIO[R, Nothing]

See also
See zio.ZIO.haltWith
final def handleChildrenWith[R, A](taskr: RIO[R, A])(supervisor: (IndexedSeq[Fiber[_, _]]) ⇒ ZIO[R, Nothing, _]): RIO[R, A]

See also
See zio.ZIO.handleChildrenWith
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
final def identity[R]: ZIO[R, Nothing, R]

See also
See zio.ZIO.identity
final val interrupt: UIO[Nothing]

See also
See zio.ZIO.interrupt
final def interruptChildren[R, A](taskr: RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.interruptChildren
final def interruptible[R, A](taskr: RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.interruptible
final def interruptibleMask[R, A](k: (InterruptStatusRestore) ⇒ RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.interruptibleMask
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def left[R, A](a: A): RIO[R, Either[A, Nothing]]

See also
See zio.ZIO.left
final def lock[R, A](executor: Executor)(taskr: RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.lock
final def mergeAll[R, A, B](in: Iterable[RIO[R, A]])(zero: B)(f: (B, A) ⇒ B): RIO[R, B]

See also
See zio.ZIO.mergeAll
final def mergeAllPar[R, A, B](in: Iterable[RIO[R, A]])(zero: B)(f: (B, A) ⇒ B): RIO[R, B]

See also
See zio.ZIO.mergeAllPar
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final val never: UIO[Nothing]

See also
See zio.ZIO.never
final val none: UIO[Option[Nothing]]

See also
See zio.ZIO.none
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def provide[R, A](r: R): (RIO[R, A]) ⇒ Task[A]

See also
See zio.ZIO.provide
final def raceAll[R, R1 <: R, A](taskr: RIO[R, A], taskrs: Iterable[RIO[R1, A]]): RIO[R1, A]

See also
See zio.ZIO.raceAll
final def reduceAll[R, R1 <: R, A](a: RIO[R, A], as: Iterable[RIO[R1, A]])(f: (A, A) ⇒ A): RIO[R1, A]

See also
See zio.ZIO.reduceAll
final def reduceAllPar[R, R1 <: R, A](a: RIO[R, A], as: Iterable[RIO[R1, A]])(f: (A, A) ⇒ A): RIO[R1, A]

See also
See zio.ZIO.reduceAllPar
def replicate[R, A](n: Int)(effect: RIO[R, A]): Iterable[RIO[R, A]]

See also
See zio.ZIO.replicate
final def require[R, A](error: Throwable): (IO[Throwable, Option[A]]) ⇒ IO[Throwable, A]

See also
See zio.ZIO.require
final def reserve[R, A, B](reservation: RIO[R, Reservation[R, Throwable, A]])(use: (A) ⇒ RIO[R, B]): RIO[R, B]

See also
See zio.ZIO.reserve
def right[R, B](b: B): RIO[R, Either[Nothing, B]]

See also
zio.ZIO.right
final def runtime[R]: ZIO[R, Nothing, Runtime[R]]

See also
See zio.ZIO.runtime
final def sequence[R, A](in: Iterable[RIO[R, A]]): RIO[R, List[A]]
See zio.ZIO.sequence
final def sequencePar[R, A](as: Iterable[RIO[R, A]]): RIO[R, List[A]]
See zio.ZIO.sequencePar
final def sequenceParN[R, A](n: Int)(as: Iterable[RIO[R, A]]): RIO[R, List[A]]
See zio.ZIO.sequenceParN
final def sleep(duration: Duration): RIO[Clock, Unit]

See also
See zio.ZIO.sleep
def some[R, A](a: A): RIO[R, Option[A]]

See also
zio.ZIO.some
final def succeed[A](a: A): UIO[A]

See also
See zio.ZIO.succeed
final def succeedLazy[A](a: ⇒ A): UIO[A]

See also
See zio.ZIO.succeedLazy
final def superviseStatus[R, A](status: SuperviseStatus)(taskr: RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.superviseStatus
final def supervised[R, A](taskr: RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.supervised
final def swap[R, A, B](implicit ev: <:<[R, (A, B)]): RIO[R, (B, A)]

See also
See zio.ZIO.swap
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def trace: UIO[ZTrace]

See also
See zio.ZIO.trace
final def traced[R, A](zio: RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.traced
final def traverse[R, A, B](in: Iterable[A])(f: (A) ⇒ RIO[R, B]): RIO[R, List[B]]

See also
See zio.ZIO.traverse
final def traversePar[R, A, B](as: Iterable[A])(fn: (A) ⇒ RIO[R, B]): RIO[R, List[B]]

See also
See zio.ZIO.traversePar
final def traverseParN[R, A, B](n: Int)(as: Iterable[A])(fn: (A) ⇒ RIO[R, B]): RIO[R, List[B]]
Alias for ZIO.foreachParN
final def traverseParN_[R, A](n: Int)(as: Iterable[A])(f: (A) ⇒ RIO[R, _]): RIO[R, Unit]

See also
See zio.ZIO.traverseParN_
final def traversePar_[R, A](as: Iterable[A])(f: (A) ⇒ RIO[R, _]): RIO[R, Unit]

See also
See zio.ZIO.traversePar_
final def traverse_[R, A](as: Iterable[A])(f: (A) ⇒ RIO[R, _]): RIO[R, Unit]

See also
See zio.ZIO.traverse_
final def uninterruptible[R, A](taskr: RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.uninterruptible
final def uninterruptibleMask[R, A](k: (InterruptStatusRestore) ⇒ RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.uninterruptibleMask
final val unit: UIO[Unit]

See also
See zio.ZIO.unit
final def unsandbox[R, A](v: IO[Cause[Throwable], A]): RIO[R, A]

See also
See zio.ZIO.unsandbox
final def unsupervised[R, A](rio: RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.unsupervised
final def untraced[R, A](zio: RIO[R, A]): RIO[R, A]

See also
See zio.ZIO.untraced
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@native() @throws( ... )
final def when[R](b: Boolean)(rio: RIO[R, _]): RIO[R, Unit]

See also
See zio.ZIO.when
final def whenCase[R, E, A](a: A)(pf: PartialFunction[A, ZIO[R, E, _]]): ZIO[R, E, Unit]

See also
See zio.ZIO.whenCase
final def whenCaseM[R, E, A](a: ZIO[R, E, A])(pf: PartialFunction[A, ZIO[R, E, _]]): ZIO[R, E, Unit]

See also
See zio.ZIO.whenCaseM
final def whenM[R](b: RIO[R, Boolean])(rio: RIO[R, _]): RIO[R, Unit]

See also
See zio.ZIO.whenM
final val yieldNow: UIO[Unit]

See also
See zio.ZIO.yieldNow

Deprecated Value Members

final def suspend[R, A](rio: ⇒ RIO[R, A]): RIO[R, A]

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use effectSuspendTotal
final def suspendWith[R, A](p: (Platform) ⇒ RIO[R, A]): RIO[R, A]

Annotations
@deprecated
Deprecated
(Since version 1.0.0) use effectSuspendTotalWith

Inherited from AnyRef

Inherited from Any

Ungrouped