Task

Type Members

sealed abstract class Attempt[+A] extends Task[A]

The Attempt represents a strict, already evaluated result of a Task that either resulted in success, wrapped in a Now, or in an error, wrapped in a Error.
final case class Error(ex: Throwable) extends Attempt[Nothing] with Product with Serializable

Constructs an eager Task instance for a result that represents an error.
final case class EvalAlways[+A](f: () ⇒ A) extends Task[A] with Product with Serializable

Constructs a lazy Task instance.
final class EvalOnce[+A] extends Task[A] with () ⇒ A

Constructs a lazy Task instance that gets evaluated only once.
final case class Now[+A](value: A) extends Attempt[A] with Product with Serializable

Constructs an eager Task instance whose result is already known.
type OnFinish[+A] = (Scheduler, StackedCancelable, Callback[A]) ⇒ Unit

Type alias representing callbacks for create tasks.
class TypeClassInstances extends Evaluable[Task]

Groups the implementation for the type-classes defined in monix.types.
Groups the implementation for the type-classes defined in monix.types.

Definition Classes
TaskInstances

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
object Attempt extends Serializable
object EvalOnce extends Serializable
object MemoizeSuspend extends Serializable
def apply[A](f: ⇒ A): Task[A]

Returns a new task that, when executed, will emit the result of the given function executed asynchronously.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def both[A, B](a: Task[A], b: Task[B]): Task[(A, B)]

Obtain results from both a and b, nondeterministically ordering their effects.
Obtain results from both a and b, nondeterministically ordering their effects.
The two tasks are both executed asynchronously. In a multi-threading environment this means that the tasks will get executed in parallel and their results synchronized.
def chooseFirstOf[A, B](fa: Task[A], fb: Task[B]): Task[Either[(A, CancelableFuture[B]), (CancelableFuture[A], B)]]

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
def chooseFirstOfList[A](tasks: TraversableOnce[Task[A]]): Task[A]

Creates a Task that upon execution will return the result of the first completed task in the given list and then cancel the rest.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def create[A](register: (Scheduler, Callback[A]) ⇒ Cancelable): Task[A]

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. Note that execution of the register callback always happens asynchronously.
register
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.
def defer[A](task: ⇒ Task[A]): Task[A]

Promote a non-strict value representing a Task to a Task of the same type.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def eval[A](eval: Coeval[A]): Task[A]

Transforms a Coeval into a Task.
def evalAlways[A](a: ⇒ A): Task[A]

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.
def evalOnce[A](a: ⇒ A): Task[A]

Promote a non-strict value to a Task that is memoized on the first evaluation, the result being then available on subsequent evaluations.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def fork[A](fa: Task[A]): Task[A]

Mirrors the given source Task, but upon execution ensure that evaluation forks into a separate (logical) thread.
def fromFuture[A](f: Future[A]): Task[A]

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.
def gather[A](in: Seq[Task[A]]): Task[List[A]]

Nondeterministically gather results from the given sequence of tasks, returning a task that will signal a sequence of results once all tasks are finished.
Nondeterministically gather results from the given sequence of tasks, returning a task that will signal a sequence 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.
Alias for zipList.
def gatherUnordered[A](in: Seq[Task[A]]): Task[Seq[A]]

Nondeterministically gather results from the given sequence of tasks to a sequence, without keeping the original ordering of results.
Nondeterministically gather results from the given sequence of tasks to a sequence, without keeping the original ordering of results.
This function is similar to gather, but neither the effects nor the results will be ordered. Useful when you don't need ordering because it can be more efficient than gather.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

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

Definition Classes
Any
def mapBoth[A1, A2, R](fa1: Task[A1], fa2: Task[A2])(f: (A1, A2) ⇒ R): Task[R]

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 immediately, one after the other, with the result being available synchronously. 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.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def never[A]: Task[A]

A Task instance that upon evaluation will never complete.
implicit val nondeterminism: TypeClassInstances

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.

Definition Classes
TaskInstances
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def now[A](a: A): Task[A]

Returns a Task that on execution is always successful, emitting the given strict value.
def pure[A](a: A): Task[A]

Lifts a value into the task context.
Lifts a value into the task context. Alias for now.
def raiseError[A](ex: Throwable): Task[A]

Returns a task that on execution is always finishing in error emitting the specified exception.
def sequence[A](in: Seq[Task[A]]): Task[List[A]]

Given a sequence of tasks, transforms it to a task signaling a sequence, executing the tasks one by one and gathering their results in a list.
Given a sequence of tasks, transforms it to a task signaling a sequence, executing the tasks one by one and gathering their results in a list.
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 paralel.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
implicit val typeClassInstances: TypeClassInstances

Type-class instances for Task.
final val unit: Task[Unit]

A Task[Unit] provided for convenience.
def unsafeCreate[A](onFinish: (Scheduler, StackedCancelable, Callback[A]) ⇒ Unit): Task[A]

Constructs a lazy Task instance whose result will be computed asynchronously.
Constructs a lazy Task instance whose result will be computed asynchronously.
Unsafe to use directly, only use if you know what you're doing. For building Task instances safely see create.
def unsafeStartAsync[A](source: Task[A], scheduler: Scheduler, conn: StackedCancelable, cb: Callback[A]): Unit

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.
def unsafeStartNow[A](source: Task[A], scheduler: Scheduler, conn: StackedCancelable, cb: Callback[A]): Unit

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.
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 zip2[A1, A2, R](fa1: Task[A1], fa2: Task[A2]): Task[(A1, A2)]

Pairs two Task instances.
def zip3[A1, A2, A3](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3]): Task[(A1, A2, A3)]

Pairs three Task instances.
def zip4[A1, A2, A3, A4](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4]): Task[(A1, A2, A3, A4)]

Pairs four Task instances.
def zip5[A1, A2, A3, A4, A5](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4], fa5: Task[A5]): Task[(A1, A2, A3, A4, A5)]

Pairs five Task instances.
def zip6[A1, A2, A3, A4, A5, A6](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4], fa5: Task[A5], fa6: Task[A6]): Task[(A1, A2, A3, A4, A5, A6)]

Pairs six Task instances.
def zipList[A](sources: Seq[Task[A]]): Task[List[A]]

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.
def zipWith2[A1, A2, R](fa1: Task[A1], fa2: Task[A2])(f: (A1, A2) ⇒ R): Task[R]

Pairs two Task instances, creating a new instance that will apply the given mapping function to the resulting pair.
def zipWith3[A1, A2, A3, R](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3])(f: (A1, A2, A3) ⇒ R): Task[R]

Pairs three Task instances, applying the given mapping function to the result.
def zipWith4[A1, A2, A3, A4, R](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4])(f: (A1, A2, A3, A4) ⇒ R): Task[R]

Pairs four Task instances, applying the given mapping function to the result.
def zipWith5[A1, A2, A3, A4, A5, R](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4], fa5: Task[A5])(f: (A1, A2, A3, A4, A5) ⇒ R): Task[R]

Pairs five Task instances, applying the given mapping function to the result.
def zipWith6[A1, A2, A3, A4, A5, A6, R](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4], fa5: Task[A5], fa6: Task[A6])(f: (A1, A2, A3, A4, A5, A6) ⇒ R): Task[R]

Pairs six Task instances, applying the given mapping function to the result.

object Task extends TaskInstances with Serializable

Type Members

sealed abstract class Attempt[+A] extends Task[A]

final case class Error(ex: Throwable) extends Attempt[Nothing] with Product with Serializable

final case class EvalAlways[+A](f: () ⇒ A) extends Task[A] with Product with Serializable

final class EvalOnce[+A] extends Task[A] with () ⇒ A

final case class Now[+A](value: A) extends Attempt[A] with Product with Serializable

type OnFinish[+A] = (Scheduler, StackedCancelable, Callback[A]) ⇒ Unit

class TypeClassInstances extends Evaluable[Task]

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object Attempt extends Serializable

object EvalOnce extends Serializable

object MemoizeSuspend extends Serializable

def apply[A](f: ⇒ A): Task[A]

final def asInstanceOf[T0]: T0

def both[A, B](a: Task[A], b: Task[B]): Task[(A, B)]

def chooseFirstOf[A, B](fa: Task[A], fb: Task[B]): Task[Either[(A, CancelableFuture[B]), (CancelableFuture[A], B)]]

def chooseFirstOfList[A](tasks: TraversableOnce[Task[A]]): Task[A]

def clone(): AnyRef

def create[A](register: (Scheduler, Callback[A]) ⇒ Cancelable): Task[A]

def defer[A](task: ⇒ Task[A]): Task[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eval[A](eval: Coeval[A]): Task[A]

def evalAlways[A](a: ⇒ A): Task[A]

def evalOnce[A](a: ⇒ A): Task[A]

def finalize(): Unit

def fork[A](fa: Task[A]): Task[A]

def fromFuture[A](f: Future[A]): Task[A]

def gather[A](in: Seq[Task[A]]): Task[List[A]]

def gatherUnordered[A](in: Seq[Task[A]]): Task[Seq[A]]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def mapBoth[A1, A2, R](fa1: Task[A1], fa2: Task[A2])(f: (A1, A2) ⇒ R): Task[R]

final def ne(arg0: AnyRef): Boolean

def never[A]: Task[A]

implicit val nondeterminism: TypeClassInstances

final def notify(): Unit

final def notifyAll(): Unit

def now[A](a: A): Task[A]

def pure[A](a: A): Task[A]

def raiseError[A](ex: Throwable): Task[A]

def sequence[A](in: Seq[Task[A]]): Task[List[A]]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

implicit val typeClassInstances: TypeClassInstances

final val unit: Task[Unit]

def unsafeCreate[A](onFinish: (Scheduler, StackedCancelable, Callback[A]) ⇒ Unit): Task[A]

def unsafeStartAsync[A](source: Task[A], scheduler: Scheduler, conn: StackedCancelable, cb: Callback[A]): Unit

def unsafeStartNow[A](source: Task[A], scheduler: Scheduler, conn: StackedCancelable, cb: Callback[A]): Unit

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zip2[A1, A2, R](fa1: Task[A1], fa2: Task[A2]): Task[(A1, A2)]

def zip3[A1, A2, A3](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3]): Task[(A1, A2, A3)]

def zip4[A1, A2, A3, A4](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4]): Task[(A1, A2, A3, A4)]

def zip5[A1, A2, A3, A4, A5](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4], fa5: Task[A5]): Task[(A1, A2, A3, A4, A5)]

def zip6[A1, A2, A3, A4, A5, A6](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4], fa5: Task[A5], fa6: Task[A6]): Task[(A1, A2, A3, A4, A5, A6)]

def zipList[A](sources: Seq[Task[A]]): Task[List[A]]

def zipWith2[A1, A2, R](fa1: Task[A1], fa2: Task[A2])(f: (A1, A2) ⇒ R): Task[R]

def zipWith3[A1, A2, A3, R](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3])(f: (A1, A2, A3) ⇒ R): Task[R]

def zipWith4[A1, A2, A3, A4, R](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4])(f: (A1, A2, A3, A4) ⇒ R): Task[R]

def zipWith5[A1, A2, A3, A4, A5, R](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4], fa5: Task[A5])(f: (A1, A2, A3, A4, A5) ⇒ R): Task[R]

def zipWith6[A1, A2, A3, A4, A5, A6, R](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3], fa4: Task[A4], fa5: Task[A5], fa6: Task[A6])(f: (A1, A2, A3, A4, A5, A6) ⇒ R): Task[R]

Inherited from Serializable

Inherited from Serializable

Inherited from TaskInstances

Inherited from AnyRef

Inherited from Any

Ungrouped