Packages

object Task extends Companion

Source
Task.scala
Linear Supertypes
Companion, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Task
  2. Companion
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def apply[A](a: => A): Task[A]

    See also

    See monix.bio.IO.apply

  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def async[A](register: (BiCallback[Throwable, A]) => Unit): Task[A]

    See also

    See monix.bio.IO.async

  7. def async0[A](register: (Scheduler, BiCallback[Throwable, A]) => Unit): Task[A]

  8. def asyncF[A](register: (BiCallback[Throwable, A]) => Task[Unit]): Task[A]

  9. val cancelBoundary: Task[Unit]

  10. def cancelable[A](register: (BiCallback[Throwable, A]) => CancelToken[Task]): Task[A]

  11. def cancelable0[A](register: (Scheduler, BiCallback[Throwable, A]) => CancelToken[Task]): Task[A]

  12. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  13. def create[A]: CreatePartiallyApplied[Throwable, A]

  14. def defer[A](fa: => Task[A]): Task[A]

    See also

    See monix.bio.IO.defer

  15. def deferAction[A](f: (Scheduler) => Task[A]): Task[A]

  16. def deferFuture[A](fa: => Future[A]): Task[A]

  17. def deferFutureAction[A](f: (Scheduler) => Future[A]): Task[A]

  18. def delay[A](a: => A): Task[A]

    See also

    See monix.bio.IO.delay

  19. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  20. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  21. def eval[A](a: => A): Task[A]

    See also

    See monix.bio.IO.eval

  22. def evalAsync[A](a: => A): Task[A]

  23. def evalOnce[A](a: => A): Task[A]

  24. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  25. def from[F[_], A](fa: F[A])(implicit F: IOLike[F]): Task[A]

    See also

    See monix.bio.IO.from

  26. def fromCancelablePromise[A](p: CancelablePromise[A]): Task[A]

  27. def fromConcurrentEffect[F[_], A](fa: F[A])(implicit F: ConcurrentEffect[F]): Task[A]

  28. def fromEffect[F[_], A](fa: F[A])(implicit F: Effect[F]): Task[A]

  29. def fromEither[A](a: Either[Throwable, A]): Task[A]

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

  31. def fromFutureLike[F[_], A](tfa: Task[F[A]])(implicit F: FutureLift[Task, F]): Task[A]

  32. def fromReactivePublisher[A](source: Publisher[A]): Task[Option[A]]

  33. def fromTry[A](a: Try[A]): Task[A]

  34. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  35. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  36. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  37. def left[A, B](a: A): Task[Either[A, B]]

    See also

    See monix.bio.IO.left

  38. def liftFrom[F[_]](implicit F: IOLike[F]): ~>[F, Task]

  39. def liftFromConcurrentEffect[F[_]](implicit F: ConcurrentEffect[F]): ~>[F, Task]

  40. def liftFromEffect[F[_]](implicit F: Effect[F]): ~>[F, Task]

  41. def liftTo[F[_]](implicit F: IOLift[F]): ~>[Task, F]

  42. def liftToAsync[F[_]](implicit F: Async[F], eff: Effect[Task]): ~>[Task, F]

  43. def liftToConcurrent[F[_]](implicit F: Concurrent[F], eff: ConcurrentEffect[Task]): ~>[Task, F]

  44. def map2[A1, A2, R](fa1: Task[A1], fa2: Task[A2])(f: (A1, A2) => R): Task[R]

    See also

    See monix.bio.IO.map2

  45. def map3[A1, A2, A3, R](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3])(f: (A1, A2, A3) => R): Task[R]

    See also

    See monix.bio.IO.map3

  46. def map4[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]

    See also

    See monix.bio.IO.map4

  47. def map5[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]

    See also

    See monix.bio.IO.map5

  48. def map6[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]

    See also

    See monix.bio.IO.map6

  49. def mapBoth[A1, A2, R](fa1: Task[A1], fa2: Task[A2])(f: (A1, A2) => R): Task[R]

  50. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  51. def never[A]: Task[A]

    See also

    See monix.bio.IO.never

  52. def none[A]: Task[Option[A]]

    See also

    See monix.bio.IO.none

  53. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  54. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  55. def now[A](a: A): Task[A]

    See also

    See monix.bio.IO.now

  56. def parMap2[A1, A2, R](fa1: Task[A1], fa2: Task[A2])(f: (A1, A2) => R): Task[R]

  57. def parMap3[A1, A2, A3, R](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3])(f: (A1, A2, A3) => R): Task[R]

  58. def parMap4[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]

  59. def parMap5[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]

  60. def parMap6[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]

    See also

    See IO.parMap6

  61. def parSequence[A](in: Iterable[Task[A]]): Task[List[A]]

  62. def parSequenceN[A](parallelism: Int)(in: Iterable[Task[A]]): Task[List[A]]

  63. def parSequenceUnordered[A](in: Iterable[Task[A]]): Task[List[A]]

  64. def parTraverse[A, B](in: Iterable[A])(f: (A) => Task[B]): Task[List[B]]

  65. def parTraverseN[A, B](parallelism: Int)(in: Iterable[A])(f: (A) => Task[B]): Task[List[B]]

  66. def parTraverseUnordered[A, B](in: Iterable[A])(f: (A) => Task[B]): Task[List[B]]

  67. def parZip2[A1, A2, R](fa1: Task[A1], fa2: Task[A2]): Task[(A1, A2)]

    See also

    See IO.parZip2

  68. def parZip3[A1, A2, A3](fa1: Task[A1], fa2: Task[A2], fa3: Task[A3]): Task[(A1, A2, A3)]

    See also

    See IO.parZip3

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

    See also

    See IO.parZip4

  70. def parZip5[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)]

    See also

    See IO.parZip5

  71. def parZip6[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)]

    See also

    See IO.parZip6

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

    See also

    See monix.bio.IO.pure

  73. def race[A, B](fa: Task[A], fb: Task[B]): Task[Either[A, B]]

    See also

    See monix.bio.IO.race

  74. def raceMany[A](tasks: Iterable[Task[A]]): Task[A]

  75. def racePair[A, B](fa: Task[A], fb: Task[B]): Task[Either[(A, Fiber[Throwable, B]), (Fiber[Throwable, A], B)]]

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

  77. def raiseUnless(cond: Boolean)(e: => Throwable): Task[Unit]

  78. def raiseWhen(cond: Boolean)(e: => Throwable): Task[Unit]

  79. def rethrow[A](fa: Task[Either[Throwable, A]]): Task[A]

  80. def right[A, B](b: B): Task[Either[A, B]]

    See also

    See monix.bio.IO.right

  81. def sequence[A](in: Iterable[Task[A]]): Task[List[A]]

  82. def shift(ec: ExecutionContext): Task[Unit]

    See also

    See monix.bio.IO.shift

  83. val shift: Task[Unit]

    See also

    See monix.bio.IO.shift

  84. def sleep(timespan: FiniteDuration): Task[Unit]

    See also

    See monix.bio.IO.sleep

  85. def some[A](a: A): Task[Option[A]]

    See also

    See monix.bio.IO.some

  86. def suspend[A](fa: => Task[A]): Task[A]

  87. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  88. def tailRecM[A, B](a: A)(f: (A) => Task[Either[A, B]]): Task[B]

  89. def terminate[A](ex: Throwable): Task[A]

  90. def toString(): String
    Definition Classes
    AnyRef → Any
  91. def traverse[A, B](in: Iterable[A])(f: (A) => Task[B]): Task[List[B]]

  92. val unit: Task[Unit]

    See also

    See monix.bio.IO.unit

  93. def unless(cond: Boolean)(action: => Task[Unit]): Task[Unit]

  94. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  95. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  96. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  97. def when(cond: Boolean)(action: => Task[Unit]): Task[Unit]

    See also

    See monix.bio.IO.when

Deprecated Value Members

  1. def gather[A](in: Iterable[Task[A]]): Task[List[A]]

    DEPRECATED — renamed to Task.parSequence.

    DEPRECATED — renamed to Task.parSequence.

    Definition Classes
    Companion
    Annotations
    @deprecated
    Deprecated

    (Since version 0.1.0) Use parSequence

  2. def gatherN[A](parallelism: Int)(in: Iterable[Task[A]]): Task[List[A]]

    DEPRECATED — renamed to Task.parSequenceN

    DEPRECATED — renamed to Task.parSequenceN

    Definition Classes
    Companion
    Annotations
    @deprecated
    Deprecated

    (Since version 0.1.0) Use parSequenceN

  3. def gatherUnordered[A](in: Iterable[Task[A]]): Task[List[A]]

    DEPRECATED — renamed to Task.parSequenceUnordered

    DEPRECATED — renamed to Task.parSequenceUnordered

    Definition Classes
    Companion
    Annotations
    @deprecated
    Deprecated

    (Since version 0.1.0) Use parSequenceUnordered

  4. def wander[A, B](in: Iterable[A])(f: (A) => Task[B]): Task[List[B]]

    DEPRECATED — renamed to Task.parTraverse

    DEPRECATED — renamed to Task.parTraverse

    Definition Classes
    Companion
    Annotations
    @deprecated
    Deprecated

    (Since version 0.1.0) Use parTraverse

  5. def wanderN[A, B](parallelism: Int)(in: Iterable[A])(f: (A) => Task[B]): Task[List[B]]

    DEPRECATED — renamed to Task.parTraverseN

    DEPRECATED — renamed to Task.parTraverseN

    Definition Classes
    Companion
    Annotations
    @deprecated
    Deprecated

    (Since version 0.1.0) Use parTraverseN

  6. def wanderUnordered[A, B](in: Iterable[A])(f: (A) => Task[B]): Task[List[B]]

    DEPRECATED — renamed to IO.parTraverseUnordered

    DEPRECATED — renamed to IO.parTraverseUnordered

    Definition Classes
    Companion
    Annotations
    @deprecated
    Deprecated

    (Since version 3.2.0) Use parTraverseUnordered

Inherited from Companion

Inherited from AnyRef

Inherited from Any

Ungrouped