Task

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def Try[A](a: ⇒ A): Either[Throwable, A]

Utility function - evaluate a and catch and return any exceptions.

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

def apply[A](a: ⇒ A)(implicit S: Strategy): Task[A]

Create a Future that will evaluate a using the given Strategy.

final def asInstanceOf[T0]: T0

def async[A](register: ((Either[Throwable, A]) ⇒ Unit) ⇒ Unit)(implicit S: Strategy): Task[A]

Create a Task from an asynchronous computation, which takes the form of a function with which we can register a callback.

implicit def asyncInstance(implicit S: Strategy): Async[Task]

def clone(): AnyRef

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

Promote a non-strict value to a Task, catching exceptions in the process.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail(e: Throwable): Task[Nothing]

A Task which fails with the given Throwable.

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

implicit def monad: Catchable[Task]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

Convert a strict value to a Task.

def ref[A](implicit S: Strategy): Task[Ref[A]]

implicit val runInstance: Run[Task]

def schedule[A](a: ⇒ A, delay: FiniteDuration)(implicit S: Strategy, scheduler: Scheduler): Task[A]

Create a Task that will evaluate a after at least the given delay.

def start[A](t: Task[A])(implicit S: Strategy): Task[Task[A]]

Given t: Task[A], start(t) returns a Task[Task[A]].

for {
  f <- Task.start { expensiveTask1 }
  // at this point, `expensive1` is evaluating in background
  g <- Task.start { expensiveTask2 }
  // now both `expensiveTask2` and `expensiveTask1` are running
  result1 <- f
  // we have forced `f`, so now only `expensiveTask2` may be running
  result2 <- g
  // we have forced `g`, so now nothing is running and we have both results
} yield (result1 + result2)

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

Produce f in the main trampolining loop, Future.step, using a fresh call stack.

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

def toString(): String

def unforkedAsync[A](register: ((Either[Throwable, A]) ⇒ Unit) ⇒ Unit): Task[A]

Like async, but run the callback in the same thread in the same thread, rather than evaluating the callback using a Strategy.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def fork[A](a: ⇒ Task[A])(implicit S: Strategy): Task[A]

Don't use this.