IO

object IO

Linear Supertypes

AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

IO
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Type Members

final class BracketAcquire[E, A] extends AnyVal
final class BracketAcquire_[E] extends AnyVal
class BracketRelease[E, A] extends AnyRef
class BracketRelease_[E] extends AnyRef

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
def absolve[E, A](v: IO[E, Either[E, A]]): IO[E, A]

See also
See zio.ZIO.absolve
def acquireReleaseExitWith[E, A, B](acquire: IO[E, A], release: (A, Exit[E, B]) ⇒ UIO[Any], use: (A) ⇒ IO[E, B]): IO[E, B]

See also
See acquireReleaseExitWith zio.ZIO
def acquireReleaseExitWith[E, A](acquire: IO[E, A]): BracketExitAcquire[Any, E, A]

See also
See acquireReleaseExitWith zio.ZIO
def acquireReleaseWith[E, A, B](acquire: IO[E, A], release: (A) ⇒ UIO[Any], use: (A) ⇒ IO[E, B]): IO[E, B]

See also
See acquireReleaseWith zio.ZIO
def acquireReleaseWith[E, A](acquire: IO[E, A]): BracketAcquire[E, A]

See also
See acquireReleaseWith zio.ZIO
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
def async[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ Any, blockingOn: Id = Fiber.Id.None): IO[E, A]

See also
See zio.ZIO.async
def asyncInterrupt[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ Either[Canceler[Any], IO[E, A]], blockingOn: Id = Fiber.Id.None): IO[E, A]

See also
See zio.ZIO.asyncInterrupt
def asyncMaybe[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ Option[IO[E, A]], blockingOn: Id = Fiber.Id.None): IO[E, A]

See also
See zio.ZIO.asyncMaybe
def asyncZIO[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ IO[E, Any]): IO[E, A]

See also
See zio.ZIO.asyncZIO
def attempt[A](effect: ⇒ A): Task[A]

See also
See zio.ZIO.attempt
def attemptBlocking[A](effect: ⇒ A): Task[A]

See also
See zio.ZIO.attemptBlocking
def attemptBlockingCancelable[A](effect: ⇒ A)(cancel: UIO[Unit]): Task[A]

See also
See zio.ZIO.attemptBlockingCancelable
def attemptBlockingIO[A](effect: ⇒ A): IO[IOException, A]

See also
See zio.ZIO.attemptBlockingIO
def attemptBlockingInterrupt[A](effect: ⇒ A): Task[A]

See also
See zio.ZIO.attemptBlockingInterrupt
def blocking[E, A](zio: IO[E, A]): IO[E, A]

See also
See zio.ZIO.blocking
def blockingExecutor: UIO[Executor]

See also
See zio.ZIO.blockingExecutor
def checkInterruptible[E, A](f: (InterruptStatus) ⇒ IO[E, A]): IO[E, A]

See also
See zio.ZIO.checkInterruptible
def checkTraced[E, A](f: (TracingStatus) ⇒ IO[E, A]): IO[E, A]

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

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
def collect[E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ IO[Option[E], B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): IO[E, Collection[B]]

See also
See zio.ZIO.collect
def collectAll[E, A](in: NonEmptyChunk[IO[E, A]]): IO[E, NonEmptyChunk[A]]

See also
See zio.ZIO.collectAll[R,E,A](in:zio\.NonEmptyChunk*
def collectAll[E, A](in: Array[IO[E, A]])(implicit arg0: ClassTag[A]): IO[E, Array[A]]

See also
See zio.ZIO.collectAll[R,E,A](in:Array*
def collectAll[E, A](in: Set[IO[E, A]]): IO[E, Set[A]]

See also
See zio.ZIO.collectAll[R,E,A](in:Set*
def collectAll[E, A, Collection[+Element] <: Iterable[Element]](in: Collection[IO[E, A]])(implicit bf: zio.BuildFrom[Collection[IO[E, A]], A, Collection[A]]): IO[E, Collection[A]]

See also
See zio.ZIO.collectAll[R,E,A,Collection[+Element]<:Iterable[Element]]*
def collectAllDiscard[E, A](in: Iterable[IO[E, A]]): IO[E, Unit]

See also
See zio.ZIO.collectAllDiscard[R,E,A](in:Iterable*
def collectAllPar[E, A](as: NonEmptyChunk[IO[E, A]]): IO[E, NonEmptyChunk[A]]

See also
See zio.ZIO.collectAllPar[R,E,A](as:zio\.NonEmptyChunk*
def collectAllPar[E, A](as: Array[IO[E, A]])(implicit arg0: ClassTag[A]): IO[E, Array[A]]

See also
See zio.ZIO.collectAllPar[R,E,A](as:Array*
def collectAllPar[E, A](as: Set[IO[E, A]]): IO[E, Set[A]]

See also
See zio.ZIO.collectAllPar[R,E,A](as:Set*
def collectAllPar[E, A, Collection[+Element] <: Iterable[Element]](as: Collection[IO[E, A]])(implicit bf: zio.BuildFrom[Collection[IO[E, A]], A, Collection[A]]): IO[E, Collection[A]]

See also
See zio.ZIO.collectAllPar[R,E,A,Collection[+Element]<:Iterable[Element]]*
def collectAllParDiscard[E, A](in: Iterable[IO[E, A]]): IO[E, Unit]

See also
See zio.ZIO.collectAllParDiscard[R,E,A](as:Iterable*
def collectAllParN[E, A, Collection[+Element] <: Iterable[Element]](n: Int)(as: Collection[IO[E, A]])(implicit bf: zio.BuildFrom[Collection[IO[E, A]], A, Collection[A]]): IO[E, Collection[A]]

See also
See zio.ZIO.collectAllParN
def collectAllParNDiscard[E, A](n: Int)(as: Iterable[IO[E, A]]): IO[E, Unit]

See also
See zio.ZIO.collectAllParNDiscard
def collectAllSuccesses[E, A, Collection[+Element] <: Iterable[Element]](in: Collection[IO[E, A]])(implicit bf: zio.BuildFrom[Collection[IO[E, A]], A, Collection[A]]): UIO[Collection[A]]

See also
See zio.ZIO.collectAllSuccesses
def collectAllSuccessesPar[E, A, Collection[+Element] <: Iterable[Element]](as: Collection[IO[E, A]])(implicit bf: zio.BuildFrom[Collection[IO[E, A]], A, Collection[A]]): UIO[Collection[A]]

See also
See zio.ZIO.collectAllSuccessesPar
def collectAllSuccessesParN[E, A, Collection[+Element] <: Iterable[Element]](n: Int)(as: Collection[IO[E, A]])(implicit bf: zio.BuildFrom[Collection[IO[E, A]], A, Collection[A]]): UIO[Collection[A]]

See also
See zio.ZIO.collectAllSuccessesParN
def collectAllWith[E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[IO[E, A]])(f: PartialFunction[A, B])(implicit bf: zio.BuildFrom[Collection[IO[E, A]], B, Collection[B]]): IO[E, Collection[B]]

See also
See zio.ZIO.collectAllWith
def collectAllWithPar[E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[IO[E, A]])(f: PartialFunction[A, B])(implicit bf: zio.BuildFrom[Collection[IO[E, A]], B, Collection[B]]): IO[E, Collection[B]]

See also
See zio.ZIO.collectAllWithPar
def collectAllWithParN[E, A, B, Collection[+Element] <: Iterable[Element]](n: Int)(as: Collection[IO[E, A]])(f: PartialFunction[A, B])(implicit bf: zio.BuildFrom[Collection[IO[E, A]], B, Collection[B]]): IO[E, Collection[B]]

See also
See zio.ZIO.collectAllWithParN
def collectFirst[E, A, B](as: Iterable[A])(f: (A) ⇒ IO[E, Option[B]]): IO[E, Option[B]]

See also
See zio.ZIO.collectFirst
def collectPar[E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ IO[Option[E], B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): IO[E, Collection[B]]

See also
See zio.ZIO.collectPar
def collectParN[E, A, B, Collection[+Element] <: Iterable[Element]](n: Int)(in: Collection[A])(f: (A) ⇒ IO[Option[E], B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): IO[E, Collection[B]]

See also
See zio.ZIO.collectParN
def cond[E, A](predicate: Boolean, result: ⇒ A, error: ⇒ E): IO[E, A]

See also
See zio.ZIO.cond
def debug(value: Any): UIO[Unit]

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

See also
See zio.ZIO.descriptor
def descriptorWith[E, A](f: (Descriptor) ⇒ IO[E, A]): IO[E, A]

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

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

See also
See zio.ZIO.dieMessage
def done[E, A](r: ⇒ Exit[E, A]): IO[E, A]

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

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

Definition Classes
AnyRef → Any
def executor: UIO[Executor]

See also
See zio.ZIO.executor
def exists[E, A](as: Iterable[A])(f: (A) ⇒ IO[E, Boolean]): IO[E, Boolean]

See also
See zio.ZIO.exists
def fail[E](error: ⇒ E): IO[E, Nothing]

See also
See zio.ZIO.fail
def failCause[E](cause: ⇒ Cause[E]): IO[E, Nothing]

See also
See zio.ZIO.failCause
def failCauseWith[E](function: (() ⇒ ZTrace) ⇒ Cause[E]): IO[E, Nothing]

See also
See zio.ZIO.failCauseWith
val fiberId: UIO[Id]

See also
zio.ZIO.fiberId
def filter[E, A](as: Set[A])(f: (A) ⇒ IO[E, Boolean]): IO[E, Set[A]]

See also
zio.ZIO.filter[R,E,A](as:Set*
def filter[E, A, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ IO[E, Boolean])(implicit bf: zio.BuildFrom[Collection[A], A, Collection[A]]): IO[E, Collection[A]]

See also
zio.ZIO.filter[R,E,A,Collection*
def filterNot[E, A](as: Set[A])(f: (A) ⇒ IO[E, Boolean]): IO[E, Set[A]]

See also
zio.ZIO.filterNot[R,E,A](as:Set*
def filterNot[E, A, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ IO[E, Boolean])(implicit bf: zio.BuildFrom[Collection[A], A, Collection[A]]): IO[E, Collection[A]]

See also
zio.ZIO.filterNot[R,E,A,Collection*
def filterNotPar[E, A](as: Set[A])(f: (A) ⇒ IO[E, Boolean]): IO[E, Set[A]]

See also
zio.ZIO.filterNotPar[R,E,A](as:Set*
def filterNotPar[E, A, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ IO[E, Boolean])(implicit bf: zio.BuildFrom[Collection[A], A, Collection[A]]): IO[E, Collection[A]]

See also
zio.ZIO.filterNotPar[R,E,A,Collection*
def filterPar[E, A](as: Set[A])(f: (A) ⇒ IO[E, Boolean]): IO[E, Set[A]]

See also
zio.ZIO.filterPar[R,E,A](as:Set*
def filterPar[E, A, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ IO[E, Boolean])(implicit bf: zio.BuildFrom[Collection[A], A, Collection[A]]): IO[E, Collection[A]]

See also
zio.ZIO.filterPar[R,E,A,Collection*
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def firstSuccessOf[E, A](io: IO[E, A], rest: Iterable[IO[E, A]]): IO[E, A]

See also
See zio.ZIO.firstSuccessOf
def flatten[E, A](io: IO[E, IO[E, A]]): IO[E, A]

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

See also
See zio.ZIO.foldLeft
def foldRight[E, S, A](in: Iterable[A])(zero: S)(f: (A, S) ⇒ IO[E, S]): IO[E, S]

See also
See zio.ZIO.foldRight
def forall[E, A](as: Iterable[A])(f: (A) ⇒ IO[E, Boolean]): IO[E, Boolean]

See also
See zio.ZIO.forall
def foreach[E, A, B](in: NonEmptyChunk[A])(f: (A) ⇒ IO[E, B]): IO[E, NonEmptyChunk[B]]

See also
See zio.ZIO.foreach[R,E,A,B](in:zio\.NonEmptyChunk*
def foreach[E, A, B](in: Option[A])(f: (A) ⇒ IO[E, B]): IO[E, Option[B]]

See also
See zio.ZIO.foreach[R,E,A,B](in:Option*]
def foreach[E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ IO[E, (Key2, Value2)]): IO[E, Map[Key2, Value2]]

See also
See zio.ZIO.foreach[R,E,Key,Key2,Value,Value2](map:Map*
def foreach[E, A, B](in: Array[A])(f: (A) ⇒ IO[E, B])(implicit arg0: ClassTag[B]): IO[E, Array[B]]

See also
See zio.ZIO.foreach[R,E,A,B](in:Array*
def foreach[E, A, B](in: Set[A])(f: (A) ⇒ IO[E, B]): IO[E, Set[B]]

See also
See zio.ZIO.foreach[R,E,A,B](in:Set*
def foreach[E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ IO[E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): IO[E, Collection[B]]

See also
See zio.ZIO.foreach[R,E,A,B,Collection[+Element]<:Iterable[Element]]*
def foreachDiscard[E, A](as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

See also
See zio.ZIO.foreachDiscard[R,E,A](as:Iterable*
final def foreachExec[E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[A])(exec: ExecutionStrategy)(f: (A) ⇒ IO[E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): IO[E, Collection[B]]

See also
See zio.ZIO.foreachExec
def foreachPar[E, A, B](as: NonEmptyChunk[A])(fn: (A) ⇒ IO[E, B]): IO[E, NonEmptyChunk[B]]

See also
See zio.ZIO.foreachPar[R,E,A,B](as:zio\.NonEmptyChunk*
def foreachPar[E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ IO[E, (Key2, Value2)]): IO[E, Map[Key2, Value2]]

See also
See zio.ZIO.foreachPar[R,E,Key,Key2,Value,Value2](map:Map*
def foreachPar[E, A, B](as: Array[A])(fn: (A) ⇒ IO[E, B])(implicit arg0: ClassTag[B]): IO[E, Array[B]]

See also
See zio.ZIO.foreachPar[R,E,A,B](as:Array*
def foreachPar[E, A, B](as: Set[A])(fn: (A) ⇒ IO[E, B]): IO[E, Set[B]]

See also
See zio.ZIO.foreachPar[R,E,A,B](as:Set*
def foreachPar[E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[A])(fn: (A) ⇒ IO[E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): IO[E, Collection[B]]

See also
See zio.ZIO.foreachPar[R,E,A,B,Collection[+Element]<:Iterable[Element]]*
def foreachParDiscard[E, A, B](as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

See also
See zio.ZIO.foreachParDiscard[R,E,A](as:Iterable*
def foreachParN[E, A, B, Collection[+Element] <: Iterable[Element]](n: Int)(as: Collection[A])(fn: (A) ⇒ IO[E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): IO[E, Collection[B]]

See also
See zio.ZIO.foreachParN
def foreachParNDiscard[E, A, B](n: Int)(as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

See also
See zio.ZIO.foreachParNDiscard
def forkAll[E, A, Collection[+Element] <: Iterable[Element]](as: Collection[IO[E, A]])(implicit bf: zio.BuildFrom[Collection[IO[E, A]], A, Collection[A]]): UIO[Fiber[E, Collection[A]]]

See also
See zio.ZIO.forkAll
def forkAllDiscard[E, A](as: Iterable[IO[E, A]]): UIO[Unit]

See also
See zio.ZIO.forkAllDiscard
def from[Input](input: ⇒ Input)(implicit constructor: ZIOConstructor[Any, Any, Input]): ZIO[OutEnvironment, OutError, OutSuccess]
Constructs a IO value of the appropriate type for the specified input.
def fromEither[E, A](v: ⇒ Either[E, A]): IO[E, A]

See also
See zio.ZIO.fromEither
def fromFiber[E, A](fiber: ⇒ Fiber[E, A]): IO[E, A]

See also
See zio.ZIO.fromFiber
def fromFiberZIO[E, A](fiber: IO[E, Fiber[E, A]]): IO[E, A]

See also
See zio.ZIO.fromFiberZIO
def fromFunction[A](f: (Any) ⇒ A): IO[Nothing, A]

See also
zio.ZIO.fromFunction
def fromFunctionEither[E, A](f: (Any) ⇒ Either[E, A]): IO[E, A]

See also
zio.ZIO.fromFunctionEither
def fromFunctionFuture[A](f: (Any) ⇒ Future[A]): Task[A]

See also
zio.ZIO.fromFunctionFuture
def fromFunctionZIO[E, A](f: (Any) ⇒ IO[E, A]): IO[E, A]

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

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

See also
See zio.ZIO.fromFutureInterrupt
def fromOption[A](v: ⇒ Option[A]): IO[Option[Nothing], A]

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

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

Definition Classes
AnyRef → Any
Annotations
@native()
def getOrFailUnit[A](v: ⇒ Option[A]): IO[Unit, A]

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

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

See also
zio.ZIO.identity
def ifZIO[E](b: IO[E, Boolean]): IfZIO[Any, E]

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

See also
See zio.ZIO.interrupt
def interruptAs(fiberId: ⇒ Id): UIO[Nothing]

See also
See zio.ZIO.interruptAs
def interruptible[E, A](io: IO[E, A]): IO[E, A]

See also
See zio.ZIO.interruptible
def interruptibleMask[E, A](k: (InterruptStatusRestore) ⇒ IO[E, A]): IO[E, A]

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

Definition Classes
Any
def iterate[E, S](initial: S)(cont: (S) ⇒ Boolean)(body: (S) ⇒ IO[E, S]): IO[E, S]

See also
See zio.ZIO.iterate
def left[E, A](a: ⇒ A): IO[E, Either[A, Nothing]]

See also
See zio.ZIO.left
def lock[E, A](executor: ⇒ Executor)(io: IO[E, A]): IO[E, A]

See also
See zio.ZIO.lock
def loop[E, A, S](initial: S)(cont: (S) ⇒ Boolean, inc: (S) ⇒ S)(body: (S) ⇒ IO[E, A]): IO[E, List[A]]

See also
See zio.ZIO.loop
def loopDiscard[E, S](initial: S)(cont: (S) ⇒ Boolean, inc: (S) ⇒ S)(body: (S) ⇒ IO[E, Any]): IO[E, Unit]

See also
See zio.ZIO.loopDiscard
def mapN[E, A, B, C, D, F](io1: IO[E, A], io2: IO[E, B], io3: IO[E, C], io4: IO[E, D])(f: (A, B, C, D) ⇒ F): IO[E, F]

See also
zio.ZIO.mapN[R,E,A,B,C,D,F]*
def mapN[E, A, B, C, D](io1: IO[E, A], io2: IO[E, B], io3: IO[E, C])(f: (A, B, C) ⇒ D): IO[E, D]

See also
zio.ZIO.mapN[R,E,A,B,C,D]*
def mapN[E, A, B, C](io1: IO[E, A], io2: IO[E, B])(f: (A, B) ⇒ C): IO[E, C]

See also
zio.ZIO.mapN[R,E,A,B,C]*
def mapParN[E, A, B, C, D, F](io1: IO[E, A], io2: IO[E, B], io3: IO[E, C], io4: IO[E, D])(f: (A, B, C, D) ⇒ F): IO[E, F]

See also
zio.ZIO.mapParN[R,E,A,B,C,D,F]*
def mapParN[E, A, B, C, D](io1: IO[E, A], io2: IO[E, B], io3: IO[E, C])(f: (A, B, C) ⇒ D): IO[E, D]

See also
zio.ZIO.mapParN[R,E,A,B,C,D]*
def mapParN[E, A, B, C](io1: IO[E, A], io2: IO[E, B])(f: (A, B) ⇒ C): IO[E, C]

See also
zio.ZIO.mapParN[R,E,A,B,C]*
def memoize[E, A, B](f: (A) ⇒ IO[E, B]): UIO[(A) ⇒ IO[E, B]]

See also
See zio.ZIO.memoize
def mergeAll[E, A, B](in: Iterable[IO[E, A]])(zero: B)(f: (B, A) ⇒ B): IO[E, B]

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

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

Definition Classes
AnyRef
val never: UIO[Nothing]

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

See also
See zio.ZIO.none
def noneOrFail[E](o: Option[E]): IO[E, Unit]

See also
See zio.ZIO.noneOrFail
def noneOrFailWith[E, O](o: Option[O])(f: (O) ⇒ E): IO[E, Unit]

See also
See zio.ZIO.noneOrFailWith
def not[E](effect: IO[E, Boolean]): IO[E, Boolean]

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

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

Definition Classes
AnyRef
Annotations
@native()
def partition[E, A, B](in: Iterable[A])(f: (A) ⇒ IO[E, B])(implicit ev: CanFail[E]): UIO[(Iterable[E], Iterable[B])]

See also
See zio.ZIO.partition
def partitionPar[E, A, B](in: Iterable[A])(f: (A) ⇒ IO[E, B])(implicit ev: CanFail[E]): UIO[(Iterable[E], Iterable[B])]

See also
See zio.ZIO.partitionPar
def partitionParN[E, A, B](n: Int)(in: Iterable[A])(f: (A) ⇒ IO[E, B])(implicit ev: CanFail[E]): UIO[(Iterable[E], Iterable[B])]

See also
See zio.ZIO.partitionParN
def raceAll[E, A](io: IO[E, A], ios: Iterable[IO[E, A]]): IO[E, A]

See also
See zio.ZIO.raceAll
def reduceAll[E, A](a: IO[E, A], as: Iterable[IO[E, A]])(f: (A, A) ⇒ A): IO[E, A]

See also
See zio.ZIO.reduceAll
def reduceAllPar[E, A](a: IO[E, A], as: Iterable[IO[E, A]])(f: (A, A) ⇒ A): IO[E, A]

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

See also
See zio.ZIO.replicate
def replicateZIO[E, A](n: Int)(effect: IO[E, A]): IO[E, Iterable[A]]

See also
See zio.ZIO.replicateZIO
def replicateZIODiscard[E, A](n: Int)(effect: IO[E, A]): IO[E, Unit]

See also
See zio.ZIO.replicateZIODiscard
def require[E, A](error: ⇒ E): (IO[E, Option[A]]) ⇒ IO[E, A]

See also
See zio.ZIO.require
def reserve[E, A, B](reservation: IO[E, Reservation[Any, E, A]])(use: (A) ⇒ IO[E, B]): IO[E, B]

See also
See zio.ZIO.reserve
def right[E, B](b: ⇒ B): IO[E, Either[Nothing, B]]

See also
zio.ZIO.right
def runtime: UIO[Runtime[Any]]

See also
See zio.ZIO.runtime
def some[E, A](a: ⇒ A): IO[E, Option[A]]

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

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

See also
See zio.ZIO.succeedBlocking
def suspend[A](io: ⇒ IO[Throwable, A]): IO[Throwable, A]

See also
zio.ZIO.suspend
def suspendSucceed[E, A](io: ⇒ IO[E, A]): IO[E, A]

See also
See zio.ZIO.suspendSucceed
def suspendSucceedWith[E, A](p: (Platform, Id) ⇒ IO[E, A]): IO[E, A]

See also
See zio.ZIO.suspendSucceedWith
def suspendWith[A](p: (Platform, Id) ⇒ IO[Throwable, A]): IO[Throwable, A]

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

Definition Classes
AnyRef
def toString(): String

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

See also
See zio.ZIO.trace
def traced[E, A](zio: IO[E, A]): IO[E, A]

See also
See zio.ZIO.traced
def uninterruptible[E, A](io: IO[E, A]): IO[E, A]

See also
See zio.ZIO.uninterruptible
def uninterruptibleMask[E, A](k: (InterruptStatusRestore) ⇒ IO[E, A]): IO[E, A]

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

See also
See zio.ZIO.unit
def unless[E](b: ⇒ Boolean)(zio: ⇒ IO[E, Any]): IO[E, Unit]

See also
See zio.ZIO.unless
def unlessZIO[E](b: IO[E, Boolean]): UnlessZIO[Any, E]

See also
See zio.ZIO.unlessZIO
def unsandbox[E, A](v: IO[Cause[E], A]): IO[E, A]

See also
See zio.ZIO.unsandbox
def untraced[E, A](zio: IO[E, A]): IO[E, A]

See also
See zio.ZIO.untraced
def validate[E, A, B](in: NonEmptyChunk[A])(f: (A) ⇒ IO[E, B])(implicit ev: CanFail[E]): IO[::[E], NonEmptyChunk[B]]

See also
See zio.ZIO.validate[R,E,A,B](in:zio\.NonEmptyChunk*
def validate[E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ IO[E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], ev: CanFail[E]): IO[::[E], Collection[B]]

See also
See zio.ZIO.validate[R,E,A,B,Collection[+Element]<:Iterable[Element]]*
def validateDiscard[E, A](in: Iterable[A])(f: (A) ⇒ IO[E, Any])(implicit ev: CanFail[E]): IO[::[E], Unit]

See also
See zio.ZIO.validateDiscard
def validateFirst[E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ IO[E, B])(implicit bf: zio.BuildFrom[Collection[A], E, Collection[E]], ev: CanFail[E]): IO[Collection[E], B]

See also
See zio.ZIO.validateFirst
def validateFirstPar[E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ IO[E, B])(implicit bf: zio.BuildFrom[Collection[A], E, Collection[E]], ev: CanFail[E]): IO[Collection[E], B]

See also
See zio.ZIO.validateFirstPar
def validatePar[E, A, B](in: NonEmptyChunk[A])(f: (A) ⇒ IO[E, B])(implicit ev: CanFail[E]): IO[::[E], NonEmptyChunk[B]]

See also
See zio.ZIO.validatePar[R,E,A,B](in:zio\.NonEmptyChunk*
def validatePar[E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ IO[E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], ev: CanFail[E]): IO[::[E], Collection[B]]

See also
See zio.ZIO.validatePar[R,E,A,B,Collection[+Element]<:Iterable[Element]]*
def validateParDiscard[E, A](in: Iterable[A])(f: (A) ⇒ IO[E, Any])(implicit ev: CanFail[E]): IO[::[E], Unit]

See also
See zio.ZIO.validateParDiscard
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
@throws( ... ) @native()
def when[E](b: ⇒ Boolean)(io: ⇒ IO[E, Any]): IO[E, Unit]

See also
See zio.ZIO.when
def whenCase[E, A](a: ⇒ A)(pf: PartialFunction[A, IO[E, Any]]): IO[E, Unit]

See also
See zio.ZIO.whenCase
def whenCaseZIO[E, A](a: IO[E, A])(pf: PartialFunction[A, IO[E, Any]]): IO[E, Unit]

See also
See zio.ZIO.whenCaseZIO
def whenZIO[E](b: IO[E, Boolean]): WhenZIO[Any, E]

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

See also
See zio.ZIO.yieldNow

Deprecated Value Members

def bracket[E, A, B](acquire: IO[E, A], release: (A) ⇒ UIO[Any], use: (A) ⇒ IO[E, B]): IO[E, B]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use acquireReleaseWith
See also
See bracket zio.ZIO
def bracket[E, A](acquire: IO[E, A]): BracketAcquire[E, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use acquireReleaseWith
See also
See bracket zio.ZIO
def bracketExit[E, A, B](acquire: IO[E, A], release: (A, Exit[E, B]) ⇒ UIO[Any], use: (A) ⇒ IO[E, B]): IO[E, B]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use acquireReleaseExitWith
See also
See bracketExit zio.ZIO
def bracketExit[E, A](acquire: IO[E, A]): BracketExitAcquire[Any, E, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use acquireReleaseExitWith
See also
See bracketExit zio.ZIO
def collectAllParN_[E, A](n: Int)(as: Iterable[IO[E, A]]): IO[E, Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use collectAllParNDiscard
See also
See zio.ZIO.collectAllParN_
def collectAllPar_[E, A](in: Iterable[IO[E, A]]): IO[E, Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use collectAllParDiscard
See also
See zio.ZIO.collectAllPar_[R,E,A](as:Iterable*
def collectAll_[E, A](in: Iterable[IO[E, A]]): IO[E, Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use collectAllDiscard
See also
See zio.ZIO.collectAll_[R,E,A](in:Iterable*
def effect[A](effect: ⇒ A): Task[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use attempt
See also
See zio.ZIO.effect
def effectAsync[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ Any, blockingOn: Id = Fiber.Id.None): IO[E, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use async
See also
See zio.ZIO.effectAsync
def effectAsyncInterrupt[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ Either[Canceler[Any], IO[E, A]], blockingOn: Id = Fiber.Id.None): IO[E, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use asyncInterrupt
See also
See zio.ZIO.effectAsyncInterrupt
def effectAsyncM[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ IO[E, Any]): IO[E, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use asyncZIO
See also
See zio.ZIO.effectAsyncM
def effectAsyncMaybe[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ Option[IO[E, A]], blockingOn: Id = Fiber.Id.None): IO[E, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use asyncMaybe
See also
See zio.ZIO.effectAsyncMaybe
def effectBlocking[A](effect: ⇒ A): Task[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use attemptBlocking
See also
See zio.ZIO.effectBlocking
def effectBlockingCancelable[A](effect: ⇒ A)(cancel: UIO[Unit]): Task[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use attemptBlockingCancelable
See also
See zio.ZIO.effectBlockingCancelable
def effectBlockingIO[A](effect: ⇒ A): IO[IOException, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use attemptBlockingIO
See also
See zio.ZIO.effectBlockingIO
def effectBlockingInterrupt[A](effect: ⇒ A): Task[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use attemptBlockingInterrupt
See also
See zio.ZIO.effectBlockingInterrupt
def effectSuspend[A](io: ⇒ IO[Throwable, A]): IO[Throwable, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use suspend
See also
zio.ZIO.effectSuspend
def effectSuspendTotal[E, A](io: ⇒ IO[E, A]): IO[E, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use suspendSucceed
See also
See zio.ZIO.effectSuspendTotal
def effectSuspendTotalWith[E, A](p: (Platform, Id) ⇒ IO[E, A]): IO[E, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use suspendSucceedWith
See also
See zio.ZIO.effectSuspendTotalWith
def effectSuspendWith[A](p: (Platform, Id) ⇒ IO[Throwable, A]): IO[Throwable, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use suspendWith
See also
zio.ZIO.effectSuspendWith
def effectTotal[A](effect: ⇒ A): UIO[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use succeed
See also
See zio.ZIO.effectTotal
def foreachParN_[E, A, B](n: Int)(as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use foreachParNDiscard
See also
See zio.ZIO.foreachParN_
def foreachPar_[E, A, B](as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use foreachParDiscard
See also
See zio.ZIO.foreachPar_[R,E,A](as:Iterable*
def foreach_[E, A](as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use foreachDiscard
See also
See zio.ZIO.foreach_[R,E,A](as:Iterable*
def forkAll_[E, A](as: Iterable[IO[E, A]]): UIO[Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use forkAllDiscard
See also
See zio.ZIO.forkAll_
def fromFiberM[E, A](fiber: IO[E, Fiber[E, A]]): IO[E, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromFiberZIO
See also
See zio.ZIO.fromFiberM
def fromFunctionM[E, A](f: (Any) ⇒ IO[E, A]): IO[E, A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromFunctionZIO
See also
zio.ZIO.fromFunctionM
def halt[E](cause: ⇒ Cause[E]): IO[E, Nothing]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use failCause
See also
See zio.ZIO.halt
def haltWith[E](function: (() ⇒ ZTrace) ⇒ Cause[E]): IO[E, Nothing]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use failCauseWith
See also
See zio.ZIO.haltWith
def ifM[E](b: IO[E, Boolean]): IfZIO[Any, E]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use ifZIO
See also
zio.ZIO.ifM
def loop_[E, S](initial: S)(cont: (S) ⇒ Boolean, inc: (S) ⇒ S)(body: (S) ⇒ IO[E, Any]): IO[E, Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use loopDiscard
See also
See zio.ZIO.loop_
def replicateM[E, A](n: Int)(effect: IO[E, A]): IO[E, Iterable[A]]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use replicateZIO
See also
See zio.ZIO.replicateM
def replicateM_[E, A](n: Int)(effect: IO[E, A]): IO[E, Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use replicateZIODiscard
See also
See zio.ZIO.replicateM_
def unlessM[E](b: IO[E, Boolean]): UnlessZIO[Any, E]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use unlessZIO
See also
See zio.ZIO.unlessM
def validatePar_[E, A](in: Iterable[A])(f: (A) ⇒ IO[E, Any])(implicit ev: CanFail[E]): IO[::[E], Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use validateParDiscard
See also
See zio.ZIO.validatePar_
def validate_[E, A](in: Iterable[A])(f: (A) ⇒ IO[E, Any])(implicit ev: CanFail[E]): IO[::[E], Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use validateDiscard
See also
See zio.ZIO.validate_
def whenCaseM[E, A](a: IO[E, A])(pf: PartialFunction[A, IO[E, Any]]): IO[E, Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use whenCaseZIO
See also
See zio.ZIO.whenCaseM
def whenM[E](b: IO[E, Boolean]): WhenZIO[Any, E]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use whenZIO
See also
See zio.ZIO.whenM

Packages

IO

object IO

Type Members

Value Members

Deprecated Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

IO 

object IO

Type Members

Value Members

Deprecated Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

IO