The Context
under which Task is supposed to be executed.
The Context
under which Task is supposed to be executed.
This definition is of interest only when creating tasks with Task.unsafeCreate, which exposes internals and is considered unsafe to use.
is the Scheduler
in charge of evaluation on runAsync
.
is the
StackedCancelable
that handles the cancellation on runAsync
is a thread-local counter that keeps track
of the current frame index of the run-loop. The run-loop
is supposed to force an asynchronous boundary upon
reaching a certain threshold, when the task is evaluated
with
monix.execution.ExecutionModel.BatchedExecution.
And this frameIndexRef
should be reset whenever a real
asynchronous boundary happens.
See the description of FrameIndexRef.
is a set of options for customizing the task's behavior upon evaluation.
A run-loop frame index is a number representing the current run-loop
cycle, being incremented whenever a flatMap
evaluation happens.
A run-loop frame index is a number representing the current run-loop
cycle, being incremented whenever a flatMap
evaluation happens.
It gets used for automatically forcing asynchronous boundaries, according to the
ExecutionModel
injected by the Scheduler when
the task gets evaluated with runAsync
.
A reference that boxes a FrameIndex possibly using a thread-local.
A reference that boxes a FrameIndex possibly using a thread-local.
This definition is of interest only when creating tasks with Task.unsafeCreate, which exposes internals and is considered unsafe to use.
In case the Task is executed with BatchedExecution, this class boxes a FrameIndex in order to transport it over light async boundaries, possibly using a ThreadLocal, since this index is not supposed to survive when threads get forked.
The FrameIndex is a counter that increments whenever a
flatMap
operation is evaluated. And with BatchedExecution
,
whenever that counter exceeds the specified threshold, an
asynchronous boundary is automatically inserted. However this
capability doesn't blend well with light asynchronous
boundaries, for example Async
tasks that never fork logical threads or
TrampolinedRunnable
instances executed by capable schedulers. This is why
FrameIndexRef is part of the Context of execution for
Task, available for asynchronous tasks that get created with
Task.unsafeCreate.
Note that in case the execution model is not
BatchedExecution
then this reference is just a dummy, since there's no point in
keeping a counter around, plus setting and fetching from a
ThreadLocal
can be quite expensive.
Type alias representing callbacks for asynchronous tasks.
Set of options for customizing the task's behavior.
Set of options for customizing the task's behavior.
should be set to true
in
case you want flatMap
driven loops to be
auto-cancelable. Defaults to false
.
Groups the implementation for the type-classes defined in monix.types.
Groups the implementation for the type-classes defined in monix.types.
Returns a new task that, when executed, will emit the result of the given function, executed asynchronously.
Returns a new task that, when executed, will emit the result of the given function, executed asynchronously.
is the callback to execute asynchronously
Create a Task
from an asynchronous computation.
Create a Task
from an asynchronous computation.
Alias for create.
Creates a Task
that upon execution will execute both given tasks
(possibly in parallel in case the tasks are asynchronous) and will
return the result of the task that manages to complete first,
along with a cancelable future of the other task.
Creates a Task
that upon execution will execute both given tasks
(possibly in parallel in case the tasks are asynchronous) and will
return the result of the task that manages to complete first,
along with a cancelable future of the other task.
If the first task that completes
Creates a Task
that upon execution will return the result of the
first completed task in the given list and then cancel the rest.
Create a Task
from an asynchronous computation, which takes the
form of a function with which we can register a callback.
Create a Task
from an asynchronous computation, which takes the
form of a function with which we can register a callback.
This can be used to translate from a callback-based API to a straightforward monadic version.
is a function that will be called when this Task
is executed, receiving a callback as a parameter, a
callback that the user is supposed to call in order to
signal the desired outcome of this Task
.
Promote a non-strict value representing a Task to a Task of the same type.
Promote a non-strict Scala Future
to a Task
of the same type.
Promote a non-strict Scala Future
to a Task
of the same type.
The equivalent of doing:
Task.defer(Task.fromFuture(fa))
Wraps calls that generate Future
results into Task, provided
a callback with an injected Scheduler
to act as the necessary ExecutionContext
.
Wraps calls that generate Future
results into Task, provided
a callback with an injected Scheduler
to act as the necessary ExecutionContext
.
This builder helps with wrapping Future
-enabled APIs that need
an implicit ExecutionContext
to work. Consider this example:
import scala.concurrent.{ExecutionContext, Future} def sumFuture(list: Seq[Int])(implicit ec: ExecutionContext): Future[Int] = Future(list.sum)
We'd like to wrap this function into one that returns a lazy
Task
that evaluates this sum every time it is called, because
that's how tasks work best. However in order to invoke this
function an ExecutionContext
is needed:
def sumTask(list: Seq[Int])(implicit ec: ExecutionContext): Task[Int] = Task.deferFuture(sumFuture(list))
But this is not only superfluous, but against the best practices
of using Task
. The difference is that Task
takes a
Scheduler (inheriting from
ExecutionContext
) only when runAsync
happens. But with deferFutureAction
we get to have an injected
Scheduler
in the passed callback:
def sumTask(list: Seq[Int]): Task[Int] = Task.deferFutureAction { implicit scheduler => sumFuture(list) }
is the function that's going to be executed when the task
gets evaluated, generating the wrapped Future
Alias for eval.
Promote a non-strict value to a Task, catching exceptions in the process.
Promote a non-strict value to a Task, catching exceptions in the process.
Note that since Task
is not memoized, this will recompute the
value each time the Task
is executed.
Promote a non-strict value to a Task that is memoized on the first evaluation, the result being then available on subsequent evaluations.
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.
is the task that will get executed asynchronously
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
.
is the task that will get executed asynchronously
Converts the given Scala Future
into a Task
.
Converts the given Scala Future
into a Task
.
NOTE: if you want to defer the creation of the future, use in combination with defer.
Builds a Task instance out of a Scala Try
.
Nondeterministically gather results from the given collection of tasks, returning a task that will signal the same type of collection of results once all tasks are finished.
Nondeterministically gather results from the given collection of tasks, returning a task that will signal the same type of collection of results once all tasks are finished.
This function is the nondeterministic analogue of sequence
and should
behave identically to sequence
so long as there is no interaction between
the effects being gathered. However, unlike sequence
, which decides on
a total order of effects, the effects in a gather
are unordered with
respect to each other.
Although the effects are unordered, we ensure the order of results matches the order of the input sequence. Also see gatherUnordered for the more efficient alternative.
Nondeterministically gather results from the given collection of tasks, without keeping the original ordering of results.
Nondeterministically gather results from the given collection of tasks, without keeping the original ordering of results.
If the tasks in the list are set to execute asynchronously, forking logical threads, then the tasks will execute in parallel.
This function is similar to gather, but neither the effects nor the results will be ordered. Useful when you don't need ordering because:
is a list of tasks to execute
Apply a mapping functions to the results of two tasks, nondeterministically ordering their effects.
Apply a mapping functions to the results of two tasks, nondeterministically ordering their effects.
If the two tasks are synchronous, they'll get executed one after the other, with the result being available asynchronously. If the two tasks are asynchronous, they'll get scheduled for execution at the same time and in a multi-threading environment they'll execute in parallel and have their results synchronized.
A Task instance that upon evaluation will never complete.
Type-class instances for Task that have nondeterministic effects for Applicative.
Type-class instances for Task that have nondeterministic effects for Applicative.
It can be optionally imported in scope to make map2
and ap
to
potentially run tasks in parallel.
Returns a Task
that on execution is always successful, emitting
the given strict value.
Lifts a value into the task context.
Lifts a value into the task context. Alias for now.
Returns a task that on execution is always finishing in error emitting the specified exception.
Given a TraversableOnce
of tasks, transforms it to a task signaling
the collection, executing the tasks one by one and gathering their
results in the same collection.
Given a TraversableOnce
of tasks, transforms it to a task signaling
the collection, executing the tasks one by one and gathering their
results in the same collection.
This operation will execute the tasks one by one, in order, which means that both effects and results will be ordered. See gather and gatherUnordered for unordered results or effects, and thus potential of running in parallel.
It's a simple version of traverse.
Alias for defer.
Keeps calling f
until it returns a Right
result.
Keeps calling f
until it returns a Right
result.
Based on Phil Freeman's Stack Safety for Free.
Given a TraversableOnce[A]
and a function A => Task[B]
, sequentially
apply the function to each element of the collection and gather their
results in the same collection.
Given a TraversableOnce[A]
and a function A => Task[B]
, sequentially
apply the function to each element of the collection and gather their
results in the same collection.
It's a generalized version of sequence.
Type-class instances for Task.
A Task[Unit]
provided for convenience.
Constructs a lazy Task instance whose result will be computed asynchronously.
Constructs a lazy Task instance whose result will be computed asynchronously.
**WARNING:** Unsafe to use directly, only use if you know
what you're doing. For building Task
instances safely
see Task.create.
Rules of usage:
StackedCancelable
can be used to store
cancelable references that will be executed upon cancel;
every push
must happen at the beginning, before any
execution happens and pop
must happen afterwards
when the processing is finished, before signaling the
resultFrameRef
indicates the current frame
index and must be reset on real asynchronous boundaries
(which avoids doing extra async boundaries in batched
execution mode)onSuccess
, onError
),
another async boundary is necessary, but can also
happen with the scheduler's facilities for trampolined
execution (e.g. asyncOnSuccess
and asyncOnError
)**WARNING:** note that not only is this builder unsafe, but also unstable, as the OnFinish callback type is exposing volatile internal implementation details. This builder is meant to create optimized asynchronous tasks, but for normal usage prefer Task.create.
Unsafe utility - starts the execution of a Task with a guaranteed asynchronous boundary, by providing the needed Scheduler, StackedCancelable and Callback.
Unsafe utility - starts the execution of a Task with a guaranteed asynchronous boundary, by providing the needed Scheduler, StackedCancelable and Callback.
DO NOT use directly, as it is UNSAFE to use, unless you know
what you're doing. Prefer Task.runAsync
and Task.fork
.
Unsafe utility - starts the execution of a Task, by providing the needed Scheduler, StackedCancelable and Callback.
Unsafe utility - starts the execution of a Task, by providing the needed Scheduler, StackedCancelable and Callback.
DO NOT use directly, as it is UNSAFE to use, unless you know what you're doing. Prefer Task.runAsync.
Unsafe utility - starts the execution of a Task with a guaranteed trampolined asynchronous boundary, by providing the needed Scheduler, StackedCancelable and Callback.
Unsafe utility - starts the execution of a Task with a guaranteed trampolined asynchronous boundary, by providing the needed Scheduler, StackedCancelable and Callback.
DO NOT use directly, as it is UNSAFE to use, unless you know
what you're doing. Prefer Task.runAsync
and Task.fork
.
Given a TraversableOnce[A]
and a function A => Task[B]
,
nondeterministically apply the function to each element of the collection
and return a task that will signal a collection of the results once all
tasks are finished.
Given a TraversableOnce[A]
and a function A => Task[B]
,
nondeterministically apply the function to each element of the collection
and return a task that will signal a collection of the results once all
tasks are finished.
This function is the nondeterministic analogue of traverse
and should
behave identically to traverse
so long as there is no interaction between
the effects being gathered. However, unlike traverse
, which decides on
a total order of effects, the effects in a wander
are unordered with
respect to each other.
Although the effects are unordered, we ensure the order of results matches the order of the input sequence. Also see wanderUnordered for the more efficient alternative.
It's a generalized version of gather.
Given a TraversableOnce[A]
and a function A => Task[B]
,
nondeterministically apply the function to each element of the collection
without keeping the original ordering of the results.
Given a TraversableOnce[A]
and a function A => Task[B]
,
nondeterministically apply the function to each element of the collection
without keeping the original ordering of the results.
This function is similar to wander, but neither the effects nor the results will be ordered. Useful when you don't need ordering because:
It's a generalized version of gatherUnordered.
Pairs two Task instances.
Pairs three Task instances.
Pairs four Task instances.
Pairs five Task instances.
Pairs six Task instances.
Gathers the results from a sequence of tasks into a single list.
Gathers the results from a sequence of tasks into a single list. The effects are not ordered, but the results are.
Pairs two Task instances, creating a new instance that will apply the given mapping function to the resulting pair.
Pairs three Task instances, applying the given mapping function to the result.
Pairs four Task instances, applying the given mapping function to the result.
Pairs five Task instances, applying the given mapping function to the result.
Pairs six Task instances, applying the given mapping function to the result.