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.
is the scheduler triggering the asynchronous boundary
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.
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
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.
is the callback to execute if the task gets canceled prematurely
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.
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 the this Task
run-loop begins executing on the given
scheduler.
Alias for Task.fork(fa,scheduler).
is the scheduler to use for execution
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).
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)
is the
ExecutionModel
with which the source will get evaluated on runAsync
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)
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
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.
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.
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.
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.
Without invoking runAsync
on a Task
, nothing
gets evaluated, as a Task
has lazy behavior.
is an injected Scheduler that gets used whenever asynchronous boundaries are needed when evaluating the task
a CancelableFuture that can be used to extract the result or to cancel a running task.
Triggers the asynchronous execution.
Triggers the asynchronous execution.
Without invoking runAsync
on a Task
, nothing
gets evaluated, as a Task
has lazy behavior.
is a callback that will be invoked upon completion.
is an injected Scheduler that gets used whenever asynchronous boundaries are needed when evaluating the task
a Cancelable that can be used to cancel a running task
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.
is a callback that will be invoked upon completion.
is an injected Scheduler that gets used whenever asynchronous boundaries are needed when evaluating the task
a Cancelable that can be used to cancel a running task
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
.
Right(result)
in case a result was processed,
or Left(future)
in case an asynchronous boundary
was hit and further async execution is needed
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.
Deprecated overload.
Deprecated overload. Use runOnComplete.
(Since version 2.1.3) Renamed to runOnComplete
Task
represents a specification for a possibly lazy or asynchronous computation, which when executed will produce anA
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, asTask
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 afterrunAsync
is called and not before that.Note that
Task
is conservative in how it spawns logical threads. Transformations likemap
andflatMap
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 executingrunAsync
.