Attempt

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

def asScala: Try[A]

Converts this attempt into a scala.util.Try.

def clone(): AnyRef

def dematerialize[B](implicit ev: <:<[A, Try[B]]): Coeval[B]

Dematerializes the source's result from a Try.

def dematerializeAttempt[B](implicit ev: <:<[A, Attempt[B]]): Attempt[B]

Dematerializes the source's result from an Attempt.

def doOnFinish(f: (Option[Throwable]) ⇒ Coeval[Unit]): Coeval[A]

Returns a new Coeval in which f is scheduled to be run on completion.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def failed: Attempt[Throwable]

Returns a failed projection of this coeval.

def finalize(): Unit

def flatMap[B](f: (A) ⇒ Coeval[B]): Coeval[B]

Creates a new Coeval by applying a function to the successful result of the source, and returns a new instance equivalent to the result of the function.

def flatten[B](implicit ev: <:<[A, Coeval[B]]): Coeval[B]

Given a source Coeval that emits another Coeval, this function flattens the result, returning a Coeval equivalent to the emitted Coeval by the source.

final def getClass(): Class[_]

def hashCode(): Int

def isFailure: Boolean

Returns true if result is an error.

final def isInstanceOf[T0]: Boolean

def isSuccess: Boolean

Returns true if value is a successful one.

def map[B](f: (A) ⇒ B): Coeval[B]

Returns a new Coeval that applies the mapping function to the element emitted by the source.

def materialize: Coeval[Try[A]]

Creates a new Coeval that will expose any triggered error from the source.

def materializeAttempt: Attempt[Attempt[A]]

Creates a new Coeval that will expose any triggered error from the source.

def memoize: Attempt[A]

Memoizes the result on the computation and reuses it on subsequent invocations of runAsync.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onErrorFallbackTo[B >: A](that: Coeval[B]): Coeval[B]

Creates a new coeval that in case of error will fallback to the given backup coeval.

def onErrorHandle[U >: A](f: (Throwable) ⇒ U): Coeval[U]

Creates a new coeval that will handle any matching throwable that this coeval might emit.

def onErrorHandleWith[B >: A](f: (Throwable) ⇒ Coeval[B]): Coeval[B]

Creates a new coeval that will handle any matching throwable that this coeval might emit by executing another coeval.

def onErrorRecover[U >: A](pf: PartialFunction[Throwable, U]): Coeval[U]

Creates a new coeval that on error will try to map the error to another value using the provided partial function.

def onErrorRecoverWith[B >: A](pf: PartialFunction[Throwable, Coeval[B]]): Coeval[B]

Creates a new coeval that will try recovering from an error by matching it with another coeval using the given partial function.

def onErrorRestart(maxRetries: Long): Coeval[A]

Creates a new coeval that in case of error will retry executing the source again and again, until it succeeds.

def onErrorRestartIf(p: (Throwable) ⇒ Boolean): Coeval[A]

Creates a new coeval that in case of error will retry executing the source again and again, until it succeeds.

def productIterator: Iterator[Any]

def productPrefix: String

def restartUntil(p: (A) ⇒ Boolean): Coeval[A]

Given a predicate function, keep retrying the coeval until the function returns true.

def runAttempt: Attempt[A]

Evaluates the underlying computation and returns the result or any triggered errors as a Coeval.Attempt.

def runTry: Try[A]

Evaluates the underlying computation and returns the result or any triggered errors as a scala.util.Try.

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

def task: Task[A]

Converts the source Coeval into a Task.

def toString(): String

def value: A

Evaluates the underlying computation and returns the result.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[B](that: Coeval[B]): Coeval[(A, B)]

Zips the values of this and that coeval, and creates a new coeval that will emit the tuple of their results.

def zipMap[B, C](that: Coeval[B])(f: (A, B) ⇒ C): Coeval[C]

Zips the values of this and that and applies the given mapping function on their results.

def zipWith[B, C](that: Coeval[B])(f: (A, B) ⇒ C): Coeval[C]