ExitResult

abstract def canEqual(that: Any): Boolean

abstract def productArity: Int

abstract def productElement(n: Int): Any

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

final def bimap[E1, A1](f: (E) ⇒ E1, g: (A) ⇒ A1): ExitResult[E1, A1]

Maps over both the error and value type.

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def flatMap[E1 >: E, A1](f: (A) ⇒ ExitResult[E1, A1]): ExitResult[E1, A1]

Flat maps over the value ty pe.

final def fold[Z](failed: (Cause[E]) ⇒ Z, completed: (A) ⇒ Z): Z

Folds over the value or cause.

final def getClass(): Class[_]

final def getOrElse[A1 >: A](orElse: (Cause[E]) ⇒ A1): A1

Retrieves the A if succeeded, or else returns the specified default A.

def hashCode(): Int

final def interrupted: Boolean

Determines if the result is interrupted.

final def isInstanceOf[T0]: Boolean

final def leftMap[E1](f: (E) ⇒ E1): ExitResult[E1, A]

Maps over the error type.

final def map[A1](f: (A) ⇒ A1): ExitResult[E, A1]

Maps over the value type.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def productIterator: Iterator[Any]

def productPrefix: String

final def redeem[E1, B](failed: (Cause[E]) ⇒ IO[E1, B], completed: (A) ⇒ IO[E1, B]): IO[E1, B]

Effectfully folds over the value or cause.

final def succeeded: Boolean

Determines if the result is a success.

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

final def toEither: Either[Throwable, A]

Converts the ExitResult to an Either[Throwable, A], by wrapping the cause in FiberFailure (if the result is failed).

def toString(): String

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: ExitResult[E1, B]): ExitResult[E1, (A, B)]

Zips this result together with the specified result.

final def zipPar[E1 >: E, B](that: ExitResult[E1, B]): ExitResult[E1, (A, B)]

Zips this result together with the specified result, in parallel.

final def zipWith[E1 >: E, B, C](that: ExitResult[E1, B])(f: (A, B) ⇒ C, g: (Cause[E], Cause[E1]) ⇒ Cause[E1]): ExitResult[E1, C]

Zips this together with the specified result using the combination functions.