Packages

sealed abstract class Task[+A] extends Serializable

Task represents a specification for a possibly lazy or 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]
Source
Task.scala
Linear Supertypes
Serializable, Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Task
  2. Serializable
  3. Serializable
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def asyncBoundary(s: Scheduler): Task[A]

    Introduces an asynchronous boundary at the current stage in the asynchronous processing pipeline, making processing to jump on the given Scheduler (until the next async boundary).

    Introduces an asynchronous boundary at the current stage in the asynchronous processing pipeline, making processing to jump on the given Scheduler (until the next async boundary).

    Consider the following example:

    import monix.execution.Scheduler
val io = Scheduler.io()

val source = Task(1).executeOn(io).map(_ + 1)

    That task is being forced to execute on the io scheduler, including the map transformation that follows after executeOn. But what if we want to jump with the execution run-loop on another scheduler for the following transformations?

    Then we can do:

    import monix.execution.Scheduler.global

source.asyncBoundary(global).map(_ + 2)

    In this sample, whatever gets evaluated by the source will happen on the io scheduler, however the asyncBoundary call will make all subsequent operations to happen on the specified global scheduler.

    s

    is the scheduler triggering the asynchronous boundary

  6. def asyncBoundary: Task[A]

    Introduces an asynchronous boundary at the current stage in the asynchronous processing pipeline.

    Introduces an asynchronous boundary at the current stage in the asynchronous processing pipeline.

    Consider the following example:

    import monix.execution.Scheduler
val io = Scheduler.io()

val source = Task(1).executeOn(io).map(_ + 1)

    That task is being forced to execute on the io scheduler, including the map transformation that follows after executeOn. But what if we want to jump with the execution run-loop on the default scheduler for the following transformations?

    Then we can do:

    source.asyncBoundary.map(_ + 2)

    In this sample, whatever gets evaluated by the source will happen on the io scheduler, however the asyncBoundary call will make all subsequent operations to happen on the default scheduler.

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

  9. 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.

    See also

    delayExecutionWith for delaying the execution of the source with a customizable trigger.

  10. 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.

    As an example, these are equivalent (in the observed effects and result, not necessarily in implementation):

    val ta = source.delayExecution(10.seconds)
val tb = source.delayExecutionWith(Task.unit.delayExecution(10.seconds))
    See also

    delayExecution for delaying the execution of the source with a simple timespan

  11. 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.

    See also

    delayResultBySelector for applying different delay strategies depending on the signaled result.

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

    Returns a task that executes the source immediately on runAsync, but with the result delayed by the specified selector.

    Returns a task that executes the source immediately on runAsync, but with the result delayed by the specified selector.

    The selector generates another Task whose execution will delay the signaling of the result generated by the source. Compared with delayResult this gives you an opportunity to apply different delay strategies depending on the signaled result.

    As an example, these are equivalent (in the observed effects and result, not necessarily in implementation):

    val t1 = source.delayResult(10.seconds)
val t2 = source.delayResultBySelector(_ =>
  Task.unit.delayExecution(10.seconds))

    Note that if an error happens, then it is streamed immediately with no delay.

    See also

    delayResult for delaying with a simple timeout

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

    Dematerializes the source's result from a Try.

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

    Dematerializes the source's result from an Attempt.

  15. def doOnCancel(callback: Task[Unit]): Task[A]

    Returns a new Task that will mirror the source, but that will execute the given callback if the task gets canceled before completion.

    Returns a new Task that will mirror the source, but that will execute the given callback if the task gets canceled before completion.

    This only works for premature cancellation. See doOnFinish for triggering callbacks when the source finishes.

    callback

    is the callback to execute if the task gets canceled prematurely

  16. 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.

    NOTE: The given function is only called when the task is complete. However the function does not get called if the task gets canceled. Cancellation is a process that's concurrent with the execution of a task and hence needs special handling.

    See doOnCancel for specifying a callback to call on canceling a task.

  17. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  18. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  19. def executeOn(s: Scheduler): Task[A]

    Mirrors the given source Task, but upon execution ensure that evaluation forks into a separate (logical) thread spawned by the given scheduler.

    Mirrors the given source Task, but upon execution ensure that evaluation forks into a separate (logical) thread spawned by the given scheduler.

    The given Scheduler will be used for execution of the Task, effectively overriding the Scheduler that's passed in runAsync. Thus you can execute a whole Task on a separate thread-pool, useful for example in case of doing I/O.

    NOTE: the logic one cares about won't necessarily end up executed on the given scheduler, or for transformations that happen from here on. It all depends on what overrides or asynchronous boundaries happen. But this function guarantees that this Task run-loop begins executing on the given scheduler.

    Alias for Task.fork(fa,scheduler).

    s

    is the scheduler to use for execution

  20. def executeWithFork: Task[A]

    Mirrors the given source Task, but upon execution ensure that evaluation forks into a separate (logical) thread.

    Mirrors the given source Task, but upon execution ensure that evaluation forks into a separate (logical) thread.

    The Scheduler used will be the one that is used to start the run-loop in runAsync.

    Alias for Task.fork(fa).

  21. def executeWithModel(em: ExecutionModel): Task[A]

    Returns a new task that will execute the source with a different ExecutionModel.

    Returns a new task that will execute the source with a different ExecutionModel.

    This allows fine-tuning the options injected by the scheduler locally. Example:

    import monix.execution.ExecutionModel.AlwaysAsyncExecution
task.executeWithModel(AlwaysAsyncExecution)
    em

    is the ExecutionModel with which the source will get evaluated on runAsync

  22. def executeWithOptions(f: (Options) ⇒ Options): Task[A]

    Returns a new task that will execute the source with a different set of Options.

    Returns a new task that will execute the source with a different set of Options.

    This allows fine-tuning the default options. Example:

    task.executeWithOptions(_.enableAutoCancelableRunLoops)
    f

    is a function that takes the source's current set of options and returns a modified set of options that will be used to execute the source upon runAsync

  23. 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.

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

  26. 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.

  27. def foreach(f: (A) ⇒ Unit)(implicit s: Scheduler): CancelableFuture[Unit]

    Triggers the evaluation of the source, executing the given function for the generated element.

    Triggers the evaluation of the source, executing the given function for the generated element.

    The application of this function has strict behavior, as the task is immediately executed.

  28. def foreachL(f: (A) ⇒ Unit): Task[Unit]

    Returns a new task that upon evaluation will execute the given function for the generated element, transforming the source into a Task[Unit].

    Returns a new task that upon evaluation will execute the given function for the generated element, transforming the source into a Task[Unit].

    Similar in spirit with normal foreach, but lazy, as obviously nothing gets executed at this point.

  29. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  30. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  31. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  32. def map[B](f: (A) ⇒ B): Task[B]

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

  33. def materialize: Task[Try[A]]

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

  34. def materializeAttempt: Task[Attempt[A]]

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

  35. def memoize: Task[A]

    Memoizes (caches) the result of the source task and reuses it on subsequent invocations of runAsync.

    Memoizes (caches) the result of the source task and reuses it on subsequent invocations of runAsync.

    The resulting task will be idempotent, meaning that evaluating the resulting task multiple times will have the same effect as evaluating it once.

    See also

    memoizeOnSuccess for a version that only caches successful results

  36. def memoizeOnSuccess: Task[A]

    Memoizes (cache) the successful result of the source task and reuses it on subsequent invocations of runAsync.

    Memoizes (cache) the successful result of the source task and reuses it on subsequent invocations of runAsync. Thrown exceptions are not cached.

    The resulting task will be idempotent, but only if the result is successful.

    See also

    memoize for a version that caches both successful results and failures

  37. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  38. final def notify(): Unit
    Definition Classes
    AnyRef
  39. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  40. 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.

  41. 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.

  42. 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.

  43. 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.

  44. 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.

  45. 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.

  46. 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.

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

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

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

    Triggers the asynchronous execution.

    Triggers the asynchronous execution.

    Without invoking runAsync on a Task, nothing gets evaluated, as a Task has lazy behavior.

    s

    is an injected Scheduler that gets used whenever asynchronous boundaries are needed when evaluating the task

    returns

    a CancelableFuture that can be used to extract the result or to cancel a running task.

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

    Triggers the asynchronous execution.

    Triggers the asynchronous execution.

    Without invoking runAsync on a Task, nothing gets evaluated, as a Task has lazy behavior.

    cb

    is a callback that will be invoked upon completion.

    s

    is an injected Scheduler that gets used whenever asynchronous boundaries are needed when evaluating the task

    returns

    a Cancelable that can be used to cancel a running task

  50. def runOnComplete(f: (Try[A]) ⇒ Unit)(implicit s: Scheduler): Cancelable

    Similar to Scala's Future#onComplete, this method triggers the evaluation of a Task and invokes the given callback whenever the result is available.

    Similar to Scala's Future#onComplete, this method triggers the evaluation of a Task and invokes the given callback whenever the result is available.

    f

    is a callback that will be invoked upon completion.

    s

    is an injected Scheduler that gets used whenever asynchronous boundaries are needed when evaluating the task

    returns

    a Cancelable that can be used to cancel a running task

  51. def runSyncMaybe(implicit s: Scheduler): Either[CancelableFuture[A], A]

    Tries to execute the source synchronously.

    Tries to execute the source synchronously.

    As an alternative to runAsync, this method tries to execute the source task immediately on the current thread and call-stack.

    This method can throw whatever error is generated by the source task, whenever that error is available immediately, otherwise errors are signaled asynchronously by means of CancelableFuture.

    returns

    Right(result) in case a result was processed, or Left(future) in case an asynchronous boundary was hit and further async execution is needed

  52. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  53. 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.

  54. 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.

  55. 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.

  56. def toString(): String
    Definition Classes
    AnyRef → Any
  57. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  58. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  59. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  60. 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.

  61. def zipMap[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.

Deprecated Value Members

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

    Deprecated overload.

    Deprecated overload. Use runOnComplete.

    Annotations
    @deprecated
    Deprecated

    (Since version 2.1.3) Renamed to runOnComplete

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped