Attempt

abstract def canEqual(that: Any): Boolean

abstract def productArity: Int

abstract def productElement(n: Int): Any

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

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 coeval(implicit s: Scheduler): Coeval[Either[CancelableFuture[A], A]]

Transforms a Task into a Coeval that tries to execute the source synchronously, returning either Right(value) in case a value is available immediately, or Left(future) in case we have an asynchronous boundary.

def delayExecution(timespan: FiniteDuration): Task[A]

Returns a task that waits for the specified timespan before executing and mirroring the result of the source.

def delayExecutionWith(trigger: Task[Any]): Task[A]

Returns a task that waits for the specified trigger to succeed before mirroring the result of the source.

def delayResult(timespan: FiniteDuration): Task[A]

Returns a task that executes the source immediately on runAsync, but before emitting the onSuccess result for the specified duration.

def delayResultBySelector[B](selector: (A) ⇒ Task[B]): Task[A]

Returns a task that executes the source immediately on runAsync, but before emitting the onSuccess result for the specified duration.

def dematerialize[B](implicit ev: <:<[A, Try[B]]): Task[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.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def failed: Attempt[Throwable]

Returns a failed projection of this task.

def finalize(): Unit

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

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

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

Given a source Task that emits another Task, this function flattens the result, returning a Task equivalent to the emitted Task 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): Task[B]

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

def materialize: Task[Try[A]]

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

def materializeAttempt: Attempt[Attempt[A]]

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

def memoize: Task[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: Task[B]): Task[B]

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

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

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

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

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

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

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

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

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

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

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

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

Creates a new task 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): Task[A]

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

def runAsync(implicit s: Scheduler): CancelableFuture[A]

Triggers the asynchronous execution.

def runAsync(f: (Try[A]) ⇒ Unit)(implicit s: Scheduler): Cancelable

Triggers the asynchronous execution.

def runAsync(cb: Callback[A])(implicit s: Scheduler): Cancelable

Triggers the asynchronous execution.

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

def timeout(after: FiniteDuration): Task[A]

Returns a Task that mirrors the source Task but that triggers a TimeoutException in case the given duration passes without the task emitting any item.

def timeoutTo[B >: A](after: FiniteDuration, backup: Task[B]): Task[B]

Returns a Task that mirrors the source Task but switches to the given backup Task in case the given duration passes without the source emitting any item.

def toReactivePublisher[B >: A](implicit s: Scheduler): Publisher[B]

Converts a Task to an org.reactivestreams.Publisher that emits a single item on success, or just the error on failure.

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

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

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

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