Task
Related Docs:
object Task
| package eval
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.
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 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.
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.
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.
Dematerializes the source's result from a Try.
Dematerializes the source's result from an Attempt.
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.
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 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 the this Task run-loop begins executing
on the given scheduler.
is the scheduler to use for execution
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.
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.
Given a source Task that emits another Task, this function flattens the result, returning a Task equivalent to the emitted Task by the source.
Returns a new Task that applies the mapping function to the element emitted by the source.
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.
Memoizes the result on the computation and reuses it on subsequent
invocations of runAsync.
Creates a new task that in case of error will fallback to the given backup task.
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.
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.
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.
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.
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.
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.
Given a predicate function, keep retrying the task until the function returns true.
Triggers the asynchronous execution.
Triggers the asynchronous execution.
a CancelableFuture that can be used to extract the result or to cancel a running task.
Triggers the asynchronous execution.
Triggers the asynchronous execution.
is a callback that will be invoked upon completion.
a Cancelable that can be used to cancel a running task
Triggers the asynchronous execution.
Triggers the asynchronous execution.
is a callback that will be invoked upon completion.
a Cancelable that can be used to cancel a running task
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 switches to the given backup Task in case the given duration passes without the source emitting any item.
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.
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 and applies the given
mapping function on their results.
Taskrepresents a specification for a possibly lazy or asynchronous computation, which when executed will produce anAas a result, along with possible side-effects.Compared with
Futurefrom Scala's standard library,Taskdoes not represent a running computation or a value detached from time, asTaskdoes 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 afterrunAsyncis called and not before that.Note that
Taskis conservative in how it spawns logical threads. Transformations likemapandflatMapfor 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 executingrunAsync.