Task

Task represents a specification for an asynchronous computation, which when executed will produce an A as a result, along with possible side-effects.

Compared with Future from Scala's standard library, Task does not represent a running computation or a value detached from time, as Task does not execute anything when working with its builders or operators and it does not submit any work into any thread-pool, the execution eventually taking place only after runAsync is called and not before that.

Note that Task is conservative in how it spawns logical threads. Transformations like map and flatMap for example will default to being executed on the logical thread on which the asynchronous computation was started. But one shouldn't make assumptions about how things will end up executed, as ultimately it is the implementation's job to decide on the best execution model. All you are guaranteed is asynchronous execution after executing runAsync.

Self Type: Task[A]

Linear Supertypes

AnyRef, Any

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

Creates a new task that upon execution will return the result of the first task that completes, while canceling the other.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
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.
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.
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.
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.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def failed: Task[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.
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.
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[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def liftTry: Task[Try[A]]

Lifts the source into one that exposes possible errors.
def map[B](f: (A) ⇒ B): Task[B]

Returns a new Task that applies the mapping function to the element emitted by the source.
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.
def onErrorRecover[U >: A](pf: PartialFunction[Throwable, U]): Task[U]

Creates a new task that will handle any matching throwable that this task might emit.
def onErrorRecoverWith[B >: A](pf: PartialFunction[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 onErrorRetry(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.
def onErrorRetryIf(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.
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.
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
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
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.
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 toString(): String

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

Related Docs: object Task | package async

sealed abstract class Task[+A] extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ambWith[B >: A](other: Task[B]): Task[B]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def failed: Task[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

final def isInstanceOf[T0]: Boolean

def liftTry: Task[Try[A]]

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onErrorFallbackTo[B >: A](that: ⇒ 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 onErrorRetry(maxRetries: Long): Task[A]

def onErrorRetryIf(p: (Throwable) ⇒ 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 toString(): String

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

Inherited from AnyRef

Inherited from Any

Ungrouped