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]])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[B]

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

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

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

See also
See acquireReleaseWith zio.ZIO
def allowInterrupt(implicit trace: ZTraceElement): UIO[Unit]

See also
See zio.ZIO.allowInterrupt
def apply[A](a: ⇒ A)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): Task[A]

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

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

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

Definition Classes
TaskPlatformSpecific
def asyncZIO[A](register: ((Task[A]) ⇒ Unit) ⇒ Task[Any])(implicit trace: ZTraceElement): Task[A]

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

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

See also
See zio.ZIO.attemptBlocking
def attemptBlockingCancelable[A](effect: ⇒ A)(cancel: ⇒ UIO[Any])(implicit trace: ZTraceElement): Task[A]

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

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

See also
See zio.ZIO.blocking
def blockingExecutor(implicit trace: ZTraceElement): UIO[Executor]

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

See also
See zio.ZIO.checkInterruptible
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)])(implicit trace: ZTraceElement): 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]], trace: ZTraceElement): Task[Collection[B]]

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

See also
See zio.ZIO.collectAll[R,E,A](in:zio\.NonEmptyChunk*
def collectAll[A](in: Option[Task[A]])(implicit trace: ZTraceElement): 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], trace: ZTraceElement): Task[Array[A]]

See also
See zio.ZIO.collectAll[R,E,A](in:Array*
def collectAll[A](in: Set[Task[A]])(implicit trace: ZTraceElement): 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]], trace: ZTraceElement): Task[Collection[A]]

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

See also
See zio.ZIO.collectAllDiscard
def collectAllPar[A](as: NonEmptyChunk[Task[A]])(implicit trace: ZTraceElement): 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], trace: ZTraceElement): Task[Array[A]]

See also
See zio.ZIO.collectAllPar[R,E,A](as:Array*
def collectAllPar[A](as: Set[Task[A]])(implicit trace: ZTraceElement): 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]], trace: ZTraceElement): Task[Collection[A]]

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

See also
See zio.ZIO.collectAllParDiscard
def collectAllSuccesses[A, Collection[+Element] <: Iterable[Element]](in: Collection[Task[A]])(implicit bf: zio.BuildFrom[Collection[Task[A]], A, Collection[A]], trace: ZTraceElement): 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]], trace: ZTraceElement): UIO[Collection[A]]

See also
See zio.ZIO.collectAllSuccessesPar
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]], trace: ZTraceElement): 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]], trace: ZTraceElement): Task[Collection[B]]

See also
See zio.ZIO.collectAllWithPar
def collectFirst[A, B](as: ⇒ Iterable[A])(f: (A) ⇒ Task[Option[B]])(implicit trace: ZTraceElement): 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)])(implicit trace: ZTraceElement): 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]], trace: ZTraceElement): Task[Collection[B]]

See also
See zio.ZIO.collectPar[R,E,A,B,Collection[+Element]<:Iterable[Element]]*
def cond[A](predicate: ⇒ Boolean, result: ⇒ A, error: ⇒ Throwable)(implicit trace: ZTraceElement): Task[A]

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

See also
See zio.ZIO.debug
def descriptor(implicit trace: ZTraceElement): UIO[Descriptor]

See also
See zio.ZIO.descriptor
def descriptorWith[A](f: (Descriptor) ⇒ Task[A])(implicit trace: ZTraceElement): Task[A]

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

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

See also
See zio.ZIO.dieMessage
def done[A](r: ⇒ Exit[Throwable, A])(implicit trace: ZTraceElement): 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(implicit trace: ZTraceElement): UIO[Executor]

See also
See zio.ZIO.executor
def exists[A](as: ⇒ Iterable[A])(f: (A) ⇒ Task[Boolean])(implicit trace: ZTraceElement): Task[Boolean]

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

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

See also
See zio.ZIO.failCause
def fiberId(implicit trace: ZTraceElement): UIO[FiberId]

See also
zio.ZIO.fiberId
def filter[A](as: Set[A])(f: (A) ⇒ Task[Boolean])(implicit trace: ZTraceElement): 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]], trace: ZTraceElement): Task[Collection[A]]

See also
zio.ZIO.filter[R,E,A,Collection*
def filterNot[A](as: Set[A])(f: (A) ⇒ Task[Boolean])(implicit trace: ZTraceElement): 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]], trace: ZTraceElement): Task[Collection[A]]

See also
zio.ZIO.filterNot[R,E,A,Collection*
def filterNotPar[A](as: Set[A])(f: (A) ⇒ Task[Boolean])(implicit trace: ZTraceElement): 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]], trace: ZTraceElement): Task[Collection[A]]

See also
zio.ZIO.filterNotPar[R,E,A,Collection*
def filterPar[A](as: Set[A])(f: (A) ⇒ Task[Boolean])(implicit trace: ZTraceElement): 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]], trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): Task[A]

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

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

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

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

See also
See zio.ZIO.forall
def foreach[A, B](in: NonEmptyChunk[A])(f: (A) ⇒ Task[B])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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)])(implicit trace: ZTraceElement): 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], trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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]], trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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]], trace: ZTraceElement): Task[Collection[B]]

See also
See zio.ZIO.foreachExec
def foreachPar[A, B](as: NonEmptyChunk[A])(fn: (A) ⇒ Task[B])(implicit trace: ZTraceElement): 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)])(implicit trace: ZTraceElement): 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], trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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]], trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[Unit]

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

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

See also
See zio.ZIO.forkAllDiscard
def from[Input](input: ⇒ Input)(implicit constructor: ZIOConstructor[Any, Throwable, Input], trace: ZTraceElement): ZIO[OutEnvironment, OutError, OutSuccess]
Constructs a Task value of the appropriate type for the specified input.
def fromCompletableFuture[A](cs: ⇒ CompletableFuture[A])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[A]

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

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

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

See also
See zio.ZIO.fromFiberZIO
def fromFuture[A](make: (ExecutionContext) ⇒ Future[A])(implicit trace: ZTraceElement): Task[A]

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

See also
See zio.ZIO.fromFutureInterrupt
def fromTry[A](value: ⇒ Try[A])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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
def interrupt(implicit trace: ZTraceElement): UIO[Nothing]

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

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

See also
See zio.ZIO.interruptible
def interruptibleMask[A](k: (InterruptStatusRestore) ⇒ Task[A])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[S]

See also
See zio.ZIO.iterate
def left[A](a: ⇒ A)(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[List[A]]

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

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

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

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

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

Definition Classes
AnyRef
def never(implicit trace: ZTraceElement): UIO[Nothing]

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

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

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

See also
See zio.ZIO.noneOrFailWith
def not(effect: ⇒ Task[Boolean])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[A]

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

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

See also
See zio.ZIO.partitionPar
def raceAll[A](task: ⇒ Task[A], ios: ⇒ Iterable[Task[A]])(implicit trace: ZTraceElement): Task[A]

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

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

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

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

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

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

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

See also
zio.ZIO.right
def runtime(implicit trace: ZTraceElement): UIO[Runtime[Any]]

See also
See zio.ZIO.runtime
def runtimeConfig(implicit trace: ZTraceElement): UIO[RuntimeConfig]

See also
See zio.ZIO.runtimeConfig
def some[A](a: ⇒ A)(implicit trace: ZTraceElement): Task[Option[A]]

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

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

See also
See zio.ZIO.succeedBlocking
def suspend[A](task: ⇒ Task[A])(implicit trace: ZTraceElement): Task[A]

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

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

See also
See zio.ZIO.suspendSucceedWith
def suspendWith[A](f: (RuntimeConfig, FiberId) ⇒ Task[A])(implicit trace: ZTraceElement): 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(implicit trace: ZTraceElement): UIO[ZTrace]

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

See also
See zio.ZIO.uninterruptible
def uninterruptibleMask[A](k: (InterruptStatusRestore) ⇒ Task[A])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[A]

See also
zio.ZIO.unsandbox
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])(implicit trace: ZTraceElement): Task[Option[A]]

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

See also
See zio.ZIO.whenCase
def whenCaseZIO[A, B](a: ⇒ Task[A])(pf: PartialFunction[A, Task[B]])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[A]

See also
See zio.ZIO.withRuntimeConfig
def yieldNow(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[B]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use acquireReleaseWith
See also
See bracket zio.ZIO
def bracket[A](acquire: ⇒ Task[A]): Acquire[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])(implicit trace: ZTraceElement): Task[B]

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use acquireReleaseExitWith
See also
See bracketExit zio.ZIO
def collectAllParN[A, Collection[+Element] <: Iterable[Element]](n: ⇒ Int)(as: Collection[Task[A]])(implicit bf: zio.BuildFrom[Collection[Task[A]], A, Collection[A]], trace: ZTraceElement): Task[Collection[A]]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use collectAllPar
See also
See zio.ZIO.collectAllParN
def collectAllParNDiscard[A](n: ⇒ Int)(as: ⇒ Iterable[Task[A]])(implicit trace: ZTraceElement): Task[Unit]

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

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use collectAllParDiscard
See also
See zio.ZIO.collectAllPar_
def collectAllSuccessesParN[A, Collection[+Element] <: Iterable[Element]](n: ⇒ Int)(as: Collection[Task[A]])(implicit bf: zio.BuildFrom[Collection[Task[A]], A, Collection[A]], trace: ZTraceElement): UIO[Collection[A]]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use collectAllSuccessesPar
See also
See zio.ZIO.collectAllSuccessesParN
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]], trace: ZTraceElement): Task[Collection[B]]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use collectAllWithPar
See also
See zio.ZIO.collectAllWithParN
def collectAll_[A](in: ⇒ Iterable[Task[A]])(implicit trace: ZTraceElement): Task[Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use collectAllDiscard
See also
See zio.ZIO.collectAll_
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]], trace: ZTraceElement): Task[Collection[B]]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use collectPar
See also
See zio.ZIO.collectParN
def effect[A](effect: ⇒ A)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): Task[T]

Definition Classes
TaskPlatformSpecific
Annotations
@deprecated
Deprecated
(Since version 2.0.0) use asyncWithCompletionHandler
def effectBlocking[A](effect: ⇒ A)(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use attemptBlockingCancelable
See also
See zio.ZIO.effectBlockingCancelable
def effectBlockingInterrupt[A](effect: ⇒ A)(implicit trace: ZTraceElement): Task[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use attemptBlockingInterrupt
See also
See zio.ZIO.effectBlockingInterrupt
def effectSuspend[A](task: ⇒ Task[A])(implicit trace: ZTraceElement): Task[A]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use suspend
See also
See zio.RIO.effectSuspend
def effectSuspendTotal[A](task: ⇒ Task[A])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[A]

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use succeed
See also
See zio.ZIO.effectTotal
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]], trace: ZTraceElement): Task[Collection[B]]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use foreachPar
See also
See zio.ZIO.foreachParN
def foreachParNDiscard[A, B](n: ⇒ Int)(as: ⇒ Iterable[A])(f: (A) ⇒ Task[Any])(implicit trace: ZTraceElement): Task[Unit]

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use foreachParDiscard
See also
See zio.ZIO.foreachParN_
def foreachPar_[A, B](as: ⇒ Iterable[A])(f: (A) ⇒ Task[Any])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): 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]])(implicit trace: ZTraceElement): Task[A]

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

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use failCause
See also
See zio.ZIO.halt
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])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): 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)(implicit trace: ZTraceElement): Task[C]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use zipPar
See also
zio.ZIO.mapParN[R,E,A,B,C]*
def partitionParN[A, B](n: ⇒ Int)(in: ⇒ Iterable[A])(f: (A) ⇒ Task[B])(implicit trace: ZTraceElement): Task[(Iterable[Throwable], Iterable[B])]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use partitionPar
See also
See zio.ZIO.partitionParN
def replicateM[A](n: ⇒ Int)(effect: ⇒ Task[A])(implicit trace: ZTraceElement): 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])(implicit trace: ZTraceElement): Task[Unit]

Annotations
@deprecated
Deprecated
(Since version 2.0.0) use replicateZIODiscard
See also
See zio.ZIO.replicateM_
def require[A](error: ⇒ Throwable)(implicit trace: ZTraceElement): (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]])(implicit trace: ZTraceElement): 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