Runtime

abstract def await: UIO[Exit[E, A]]

Awaits the fiber, which suspends the awaiting fiber until the result of the fiber has been determined.

abstract def getRef[A](ref: FiberRef[A]): UIO[A]

Gets the value of the fiber ref for this fiber, or the initial value of the fiber ref, if the fiber is not storing the ref.

abstract def id: Id

The identity of the fiber.

abstract def inheritRefs: UIO[Unit]

Inherits values from all FiberRef instances into current fiber.

abstract def interruptAs(fiberId: Id): UIO[Exit[E, A]]

Interrupts the fiber as if interrupted from the specified fiber.

abstract def poll: UIO[Option[Exit[E, A]]]

Tentatively observes the fiber, but returns immediately if it is not already done.

abstract def scope: ZScope[Exit[E, A]]

abstract def status: UIO[Status]

The status of the fiber.

abstract def trace: UIO[ZTrace]

The trace of the fiber.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def *>[E1 >: E, B](that: Fiber[E1, B]): Synthetic[E1, B]

Same as zip but discards the output of the left hand side.

final def <*[E1 >: E, B](that: Fiber[E1, B]): Synthetic[E1, A]

Same as zip but discards the output of the right hand side.

final def <*>[E1 >: E, B](that: ⇒ Fiber[E1, B]): Synthetic[E1, (A, B)]

Zips this fiber and the specified fiber together, producing a tuple of their output.

final def <+>[E1 >: E, B](that: ⇒ Fiber[E1, B])(implicit ev: CanFail[E]): Synthetic[E1, Either[A, B]]

A symbolic alias for orElseEither.

def <>[E1, A1 >: A](that: ⇒ Fiber[E1, A1])(implicit ev: CanFail[E]): Synthetic[E1, A1]

A symbolic alias for orElse.

final def ==(arg0: Any): Boolean

final def as[B](b: ⇒ B): Synthetic[E, B]

Maps the output of this fiber to the specified constant.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def dump: UIO[Dump]

Generates a fiber dump with optionally excluded stack traces.

final def dumpWith(withTrace: Boolean): UIO[Dump]

Generates a fiber dump.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def fold[Z](runtime: (Runtime[E, A]) ⇒ Z, synthetic: (Synthetic[E, A]) ⇒ Z): Z

Folds over the runtime or synthetic fiber.

final def getClass(): Class[_]

def hashCode(): Int

final def interrupt: UIO[Exit[E, A]]

Interrupts the fiber from whichever fiber is calling this method.

final def interruptFork: UIO[Unit]

Interrupts the fiber from whichever fiber is calling this method.

final def isInstanceOf[T0]: Boolean

final def join: IO[E, A]

Joins the fiber, which suspends the joining fiber until the result of the fiber has been determined.

final def map[B](f: (A) ⇒ B): Synthetic[E, B]

Maps over the value the Fiber computes.

final def mapFiber[E1 >: E, B](f: (A) ⇒ Fiber[E1, B]): UIO[Fiber[E1, B]]

Passes the success of this fiber to the specified callback, and continues with the fiber that it returns.

final def mapM[E1 >: E, B](f: (A) ⇒ IO[E1, B]): Synthetic[E1, B]

Effectually maps over the value the fiber computes.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orElse[E1, A1 >: A](that: ⇒ Fiber[E1, A1])(implicit ev: CanFail[E]): Synthetic[E1, A1]

Returns a fiber that prefers this fiber, but falls back to the that one when this one fails.

final def orElseEither[E1, B](that: ⇒ Fiber[E1, B]): Synthetic[E1, Either[A, B]]

Returns a fiber that prefers this fiber, but falls back to the that one when this one fails.

final def synchronized[T0](arg0: ⇒ T0): T0

final def toFuture(implicit ev: <:<[E, Throwable]): UIO[CancelableFuture[A]]

Converts this fiber into a scala.concurrent.Future.

final def toFutureWith(f: (E) ⇒ Throwable): UIO[CancelableFuture[A]]

Converts this fiber into a scala.concurrent.Future, translating any errors to java.lang.Throwable with the specified conversion function, using Cause.squashTraceWith

final def toManaged: ZManaged[Any, Nothing, Fiber[E, A]]

Converts this fiber into a zio.ZManaged.

def toString(): String

final def unit: Synthetic[E, Unit]

Maps the output of this fiber to ().

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def zip[E1 >: E, B](that: ⇒ Fiber[E1, B]): Synthetic[E1, (A, B)]

Named alias for <*>.

final def zipLeft[E1 >: E, B](that: Fiber[E1, B]): Synthetic[E1, A]

Named alias for <*.

final def zipRight[E1 >: E, B](that: Fiber[E1, B]): Synthetic[E1, B]

Named alias for *>.

final def zipWith[E1 >: E, B, C](that: ⇒ Fiber[E1, B])(f: (A, B) ⇒ C): Synthetic[E1, C]

Zips this fiber with the specified fiber, combining their results using the specified combiner function.