Task

object Task extends TaskPlatformSpecific

Linear Supertypes

TaskPlatformSpecific, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

Task
TaskPlatformSpecific
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
def absolve[A](v: ⇒ Task[Either[Throwable, A]]): Task[A]

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

See also
See acquireReleaseExitWith zio.ZIO
def acquireReleaseExitWith[A](acquire: ⇒ Task[A]): BracketExitAcquire[Any, Throwable, A]

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

See also
See acquireReleaseWith zio.ZIO
def acquireReleaseWith[A](acquire: ⇒ Task[A]): BracketAcquire[Any, Throwable, 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[A](register: ((Task[A]) ⇒ Unit) ⇒ Any, blockingOn: ⇒ FiberId = FiberId.None): Task[A]

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

See also
See zio.ZIO.asyncInterrupt
def asyncMaybe[A](register: ((Task[A]) ⇒ Unit) ⇒ Option[Task[A]], blockingOn: ⇒ FiberId = FiberId.None): Task[A]

See also
See zio.ZIO.asyncMaybe
def asyncWithCompletionHandler[T](op: (CompletionHandler[T, Any]) ⇒ Any): Task[T]

Definition Classes
TaskPlatformSpecific
def asyncZIO[A](register: ((Task[A]) ⇒ Unit) ⇒ Task[Any]): Task[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[Any]): Task[A]

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

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

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

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

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

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

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
def collect[Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ IO[Option[Throwable], (Key2, Value2)]): Task[Map[Key2, Value2]]

See also
See zio.ZIO.collect[R,E,Key,Key2,Value,Value2](map:Map*
def collect[A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ IO[Option[Throwable], B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): Task[Collection[B]]

See also
See zio.ZIO.collect[R,E,A,B,Collection[+Element]<:Iterable[Element]]*
def collectAll[A](in: NonEmptyChunk[Task[A]]): Task[NonEmptyChunk[A]]

See also
See zio.ZIO.collectAll[R,E,A](in:zio\.NonEmptyChunk*
def collectAll[A](in: Option[Task[A]]): Task[Option[A]]

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

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

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

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

See also
See zio.ZIO.collectAllDiscard
def collectAllPar[A](as: NonEmptyChunk[Task[A]]): Task[NonEmptyChunk[A]]

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

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

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

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

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

See also
See zio.ZIO.collectAllParN
def collectAllParNDiscard[A](n: ⇒ Int)(as: ⇒ Iterable[Task[A]]): Task[Unit]

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

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

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

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

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

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

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

See also
See zio.ZIO.collectFirst
def collectPar[Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ IO[Option[Throwable], (Key2, Value2)]): Task[Map[Key2, Value2]]

See also
See zio.ZIO.collectPar[R,E,Key,Key2,Value,Value2](map:Map*
def collectPar[A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ IO[Option[Throwable], B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]]): Task[Collection[B]]

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

See also
See zio.ZIO.collectParN
def cond[A](predicate: ⇒ Boolean, result: ⇒ A, error: ⇒ Throwable): Task[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[A](f: (Descriptor) ⇒ Task[A]): Task[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[A](r: ⇒ Exit[Throwable, A]): Task[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[A](as: ⇒ Iterable[A])(f: (A) ⇒ Task[Boolean]): Task[Boolean]

See also
See zio.ZIO.exists
def fail(error: ⇒ Throwable): Task[Nothing]

See also
See zio.ZIO.fail
def failCause(cause: ⇒ Cause[Throwable]): Task[Nothing]

See also
See zio.ZIO.failCause
def failCauseWith[E <: Throwable](function: (() ⇒ ZTrace) ⇒ Cause[E]): Task[Nothing]

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

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

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

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

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

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

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

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

See also
zio.ZIO.filterPar[R,E,A](as:Set*
def filterPar[A, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ Task[Boolean])(implicit bf: zio.BuildFrom[Collection[A], A, Collection[A]]): Task[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[A](task: ⇒ Task[A], rest: ⇒ Iterable[Task[A]]): Task[A]

See also
See zio.ZIO.firstSuccessOf
def flatten[A](task: ⇒ Task[Task[A]]): Task[A]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

See also
See zio.ZIO.forkAll
def forkAllDiscard[A](as: ⇒ Iterable[Task[A]]): UIO[Unit]

See also
See zio.ZIO.forkAllDiscard
def from[Input](input: ⇒ Input)(implicit constructor: ZIOConstructor[Any, Throwable, Input]): ZIO[OutEnvironment, OutError, OutSuccess]
Constructs a Task value of the appropriate type for the specified input.
def fromCompletableFuture[A](cs: ⇒ CompletableFuture[A]): Task[A]
Alias for formCompletionStage for a concrete implementation of CompletionStage
Alias for formCompletionStage for a concrete implementation of CompletionStage

Definition Classes
TaskPlatformSpecific
def fromCompletionStage[A](cs: ⇒ CompletionStage[A]): Task[A]

Definition Classes
TaskPlatformSpecific
def fromEither[A](v: ⇒ Either[Throwable, A]): Task[A]

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

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

See also
See zio.ZIO.fromFiberZIO
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 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 getOrFail[A](v: ⇒ Option[A]): Task[A]

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

Definition Classes
AnyRef → Any
Annotations
@native()
def ifZIO(b: ⇒ Task[Boolean]): IfZIO[Any, Throwable]

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

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

See also
See zio.ZIO.interruptAs
def interruptible[A](task: ⇒ Task[A]): Task[A]

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

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

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

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

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

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

See also
See zio.ZIO.loopDiscard
def memoize[A, B](f: (A) ⇒ Task[B]): UIO[(A) ⇒ Task[B]]

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

See also
See zio.ZIO.mergeAll
def mergeAllPar[A, B](in: ⇒ Iterable[Task[A]])(zero: ⇒ B)(f: (B, A) ⇒ B): Task[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: Task[Option[Nothing]]

See also
See zio.ZIO.none
def noneOrFail(o: ⇒ Option[Throwable]): Task[Unit]

See also
See zio.ZIO.noneOrFail
def noneOrFailWith[O](o: ⇒ Option[O])(f: (O) ⇒ Throwable): Task[Unit]

See also
See zio.ZIO.noneOrFailWith
def not(effect: ⇒ Task[Boolean]): Task[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 onExecutor[A](executor: ⇒ Executor)(task: Task[A]): Task[A]

See also
See zio.ZIO.onExecutor
def partition[A, B](in: ⇒ Iterable[A])(f: (A) ⇒ Task[B]): Task[(Iterable[Throwable], Iterable[B])]

See also
See zio.ZIO.partition
def partitionPar[A, B](in: ⇒ Iterable[A])(f: (A) ⇒ Task[B]): Task[(Iterable[Throwable], Iterable[B])]

See also
See zio.ZIO.partitionPar
def partitionParN[A, B](n: ⇒ Int)(in: ⇒ Iterable[A])(f: (A) ⇒ Task[B]): Task[(Iterable[Throwable], Iterable[B])]

See also
See zio.ZIO.partitionParN
def raceAll[A](task: ⇒ Task[A], ios: ⇒ Iterable[Task[A]]): Task[A]

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

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

See also
See zio.ZIO.reduceAllPar
def replicate[A](n: ⇒ Int)(effect: ⇒ Task[A]): Iterable[Task[A]]

See also
See zio.ZIO.replicate
def replicateZIO[A](n: ⇒ Int)(effect: ⇒ Task[A]): Task[Iterable[A]]

See also
See zio.ZIO.replicateZIO
def replicateZIODiscard[A](n: ⇒ Int)(effect: ⇒ Task[A]): Task[Unit]

See also
See zio.ZIO.replicateZIODiscard
def reserve[A, B](reservation: ⇒ Task[Reservation[Any, Throwable, A]])(use: (A) ⇒ Task[B]): Task[B]

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

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

See also
See zio.ZIO.runtime
val runtimeConfig: UIO[RuntimeConfig]

See also
See zio.ZIO.runtimeConfig
def some[A](a: ⇒ A): Task[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](task: ⇒ Task[A]): Task[A]

See also
See zio.ZIO.suspend
def suspendSucceed[A](task: ⇒ Task[A]): Task[A]

See also
See zio.ZIO.suspendSucceed
def suspendSucceedWith[A](f: (RuntimeConfig, FiberId) ⇒ Task[A]): Task[A]

See also
See zio.ZIO.suspendSucceedWith
def suspendWith[A](f: (RuntimeConfig, FiberId) ⇒ Task[A]): Task[A]

See also
See zio.RIO.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[A](task: ⇒ Task[A]): Task[A]

See also
See zio.ZIO.traced
def uninterruptible[A](task: ⇒ Task[A]): Task[A]

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

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

See also
See zio.ZIO.unit
def unless[A](b: ⇒ Boolean)(zio: ⇒ Task[A]): Task[Option[A]]

See also
See zio.ZIO.unless
def unlessZIO(b: ⇒ Task[Boolean]): UnlessZIO[Any, Throwable]

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

See also
zio.ZIO.unsandbox
def untraced[A](task: ⇒ Task[A]): Task[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
@throws( ... ) @native()
def when[A](b: ⇒ Boolean)(task: ⇒ Task[A]): Task[Option[A]]

See also
See zio.ZIO.when
def whenCase[A, B](a: ⇒ A)(pf: PartialFunction[A, Task[B]]): Task[Option[B]]

See also
See zio.ZIO.whenCase
def whenCaseZIO[A, B](a: ⇒ Task[A])(pf: PartialFunction[A, Task[B]]): Task[Option[B]]

See also
See zio.ZIO.whenCaseZIO
def whenZIO(b: ⇒ Task[Boolean]): WhenZIO[Any, Throwable]

See also
See zio.ZIO.whenZIO
def withRuntimeConfig[A](runtimeConfig: ⇒ RuntimeConfig)(task: ⇒ Task[A]): Task[A]

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

See also
See zio.ZIO.yieldNow

Deprecated Value Members

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

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

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

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

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

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use collectAllParDiscard
See also
See zio.ZIO.collectAllPar_
def collectAll_[A](in: ⇒ Iterable[Task[A]]): Task[Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use collectAllDiscard
See also
See zio.ZIO.collectAll_
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[A](register: ((Task[A]) ⇒ Unit) ⇒ Any, blockingOn: ⇒ FiberId = FiberId.None): Task[A]

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

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

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use asyncMaybe
See also
See zio.ZIO.effectAsyncMaybe
def effectAsyncWithCompletionHandler[T](op: (CompletionHandler[T, Any]) ⇒ Any): Task[T]

Definition Classes
TaskPlatformSpecific
Annotations
@deprecated
Deprecated
(Since version 2.0.0) use asyncWithCompletionHandler
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[Any]): Task[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use attemptBlockingCancelable
See also
See zio.ZIO.effectBlockingCancelable
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](task: ⇒ Task[A]): Task[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use suspend
See also
See zio.RIO.effectSuspend
def effectSuspendTotal[A](task: ⇒ Task[A]): Task[A]

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

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use suspendWith
See also
See zio.RIO.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_[A, B](n: ⇒ Int)(as: ⇒ Iterable[A])(f: (A) ⇒ Task[Any]): Task[Unit]

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

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use foreachDiscard
See also
See zio.ZIO.foreach_
def forkAll_[A](as: ⇒ Iterable[Task[A]]): UIO[Unit]

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use fromFiberZIO
See also
See zio.ZIO.fromFiberM
def halt(cause: ⇒ Cause[Throwable]): Task[Nothing]

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

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use ifZIO
See also
zio.ZIO.ifM
def lock[A](executor: ⇒ Executor)(task: ⇒ Task[A]): Task[A]

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use loopDiscard
See also
See zio.ZIO.loop_
def mapN[A, B, C, D, F](task1: ⇒ Task[A], task2: ⇒ Task[B], task3: ⇒ Task[C], task4: ⇒ Task[D])(f: (A, B, C, D) ⇒ F): Task[F]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use zip
See also
zio.ZIO.mapN[R,E,A,B,C,D,F]*
def mapN[A, B, C, D](task1: ⇒ Task[A], task2: ⇒ Task[B], task3: ⇒ Task[C])(f: (A, B, C) ⇒ D): Task[D]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use zip
See also
zio.ZIO.mapN[R,E,A,B,C,D]*
def mapN[A, B, C](task1: ⇒ Task[A], task2: ⇒ Task[B])(f: (A, B) ⇒ C): Task[C]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use zip
See also
zio.ZIO.mapN[R,E,A,B,C]*
def mapParN[A, B, C, D, F](task1: ⇒ Task[A], task2: ⇒ Task[B], task3: ⇒ Task[C], task4: ⇒ Task[D])(f: (A, B, C, D) ⇒ F): Task[F]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use zipPar
See also
zio.ZIO.mapParN[R,E,A,B,C,D,F]*
def mapParN[A, B, C, D](task1: ⇒ Task[A], task2: ⇒ Task[B], task3: ⇒ Task[C])(f: (A, B, C) ⇒ D): Task[D]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use zipPar
See also
zio.ZIO.mapParN[R,E,A,B,C,D]*
def mapParN[A, B, C](task1: ⇒ Task[A], task2: ⇒ Task[B])(f: (A, B) ⇒ C): Task[C]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use zipPar
See also
zio.ZIO.mapParN[R,E,A,B,C]*
def replicateM[A](n: ⇒ Int)(effect: ⇒ Task[A]): Task[Iterable[A]]

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use replicateZIODiscard
See also
See zio.ZIO.replicateM_
def require[A](error: ⇒ Throwable): (Task[Option[A]]) ⇒ Task[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use someOrFail
See also
See zio.ZIO.require
def unlessM(b: ⇒ Task[Boolean]): UnlessZIO[Any, Throwable]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use unlessZIO
See also
See zio.ZIO.unlessM
def whenCaseM[A, B](a: ⇒ Task[A])(pf: PartialFunction[A, Task[B]]): Task[Option[B]]

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

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

Packages

Task

object Task extends TaskPlatformSpecific

Value Members

Deprecated Value Members

Inherited from TaskPlatformSpecific

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Task 

object Task extends TaskPlatformSpecific

Value Members

Deprecated Value Members

Inherited from TaskPlatformSpecific

Inherited from AnyRef

Inherited from Any

Ungrouped

Task