Attempt

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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asScala: Try[A]

Converts this attempt into a scala.util.Try.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
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.
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.

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

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

Definition Classes
Task
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.
Returns a task that waits for the specified trigger to succeed before mirroring the result of the source.
If the trigger ends in error, then the resulting task will also end in error.

Definition Classes
Task
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.
Returns a task that executes the source immediately on runAsync, but before emitting the onSuccess result for the specified duration.
Note that if an error happens, then it is streamed immediately with no delay.

Definition Classes
Task
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.
Returns a task that executes the source immediately on runAsync, but before emitting the onSuccess result for the specified duration.
Note that if an error happens, then it is streamed immediately with no delay.

Definition Classes
Task
def dematerialize[B](implicit ev: <:<[A, Try[B]]): Task[B]

Dematerializes the source's result from a Try.
Dematerializes the source's result from a Try.

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

Dematerializes the source's result from an Attempt.
Dematerializes the source's result from an Attempt.

Definition Classes
Attempt → Task
def doOnFinish(f: (Option[Throwable]) ⇒ Task[Unit]): Task[A]

Returns a new Task in which f is scheduled to be run on completion.
Returns a new Task in which f is scheduled to be run on completion. This would typically be used to release any resources acquired by this Task.
The returned Task completes when both the source and the task returned by f complete.

Definition Classes
Task
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def failed: Attempt[Throwable]

Returns a failed projection of this task.
Returns a failed projection of this task.
The failed projection is a future holding a value of type Throwable, emitting a value which is the throwable of the original task in case the original task fails, otherwise if the source succeeds, then it fails with a NoSuchElementException.

Definition Classes
Attempt → Task
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
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.
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.

Definition Classes
Task
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.
Given a source Task that emits another Task, this function flattens the result, returning a Task equivalent to the emitted Task by the source.

Definition Classes
Task
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def isFailure: Boolean

Returns true if result is an error.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
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.
Returns a new Task that applies the mapping function to the element emitted by the source.

Definition Classes
Task
def materialize: Task[Try[A]]

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

Definition Classes
Task
def materializeAttempt: Attempt[Attempt[A]]

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

Definition Classes
Attempt → Task
def memoize: Task[A]

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

Definition Classes
Task
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
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.
Creates a new task that in case of error will fallback to the given backup task.

Definition Classes
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.
Creates a new task that will handle any matching throwable that this task might emit.
See onErrorRecover for the version that takes a partial function.

Definition Classes
Task
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.
Creates a new task that will handle any matching throwable that this task might emit by executing another task.
See onErrorRecoverWith for the version that takes a partial function.

Definition Classes
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.
Creates a new task that on error will try to map the error to another value using the provided partial function.
See onErrorHandle for the version that takes a total function.

Definition Classes
Task
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.
Creates a new task that will try recovering from an error by matching it with another task using the given partial function.
See onErrorHandleWith for the version that takes a total function.

Definition Classes
Task
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.
Creates a new task that in case of error will retry executing the source again and again, until it succeeds.
In case of continuous failure the total number of executions will be maxRetries + 1.

Definition Classes
Task
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.
Creates a new task that in case of error will retry executing the source again and again, until it succeeds.
In case of continuous failure the total number of executions will be maxRetries + 1.

Definition Classes
Task
def restartUntil(p: (A) ⇒ Boolean): Task[A]

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

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

Triggers the asynchronous execution.
Triggers the asynchronous execution.
returns
a CancelableFuture that can be used to extract the result or to cancel a running task.

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

Triggers the asynchronous execution.
Triggers the asynchronous execution.
f
is a callback that will be invoked upon completion.
returns
a Cancelable that can be used to cancel a running task

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

Triggers the asynchronous execution.
Triggers the asynchronous execution.
cb
is a callback that will be invoked upon completion.
returns
a Cancelable that can be used to cancel a running task

Definition Classes
Task
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
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.
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.

Definition Classes
Task
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.
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.

Definition Classes
Task
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.
Converts a Task to an org.reactivestreams.Publisher that emits a single item on success, or just the error on failure.
See reactive-streams.org for the Reactive Streams specification.

Definition Classes
Task
def toString(): String

Definition Classes
AnyRef → Any
def value: A

Evaluates the underlying computation and returns the result.
Evaluates the underlying computation and returns the result.
NOTE: this can throw exceptions.
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( ... )
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.
Zips the values of this and that task, and creates a new task that will emit the tuple of their results.

Definition Classes
Task
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.
Zips the values of this and that and applies the given mapping function on their results.

Definition Classes
Task

Related Docs: object Attempt | package Task

sealed abstract class Attempt[+A] extends Task[A]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def asScala: Try[A]

def clone(): AnyRef

def coeval(implicit s: Scheduler): Coeval[Either[CancelableFuture[A], A]]

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

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

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

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

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

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

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def failed: Attempt[Throwable]

def finalize(): Unit

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

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

final def getClass(): Class[_]

def hashCode(): Int

def isFailure: Boolean

final def isInstanceOf[T0]: Boolean

def isSuccess: Boolean

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

def materialize: Task[Try[A]]

def materializeAttempt: Attempt[Attempt[A]]

def memoize: Task[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def toString(): String

def value: A

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)]

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

Inherited from Task[A]

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped