FutureMonad

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 aggregate[A](fs: Seq[Future[A]])(implicit arg0: Monoid[A]): Future[A]

   

   Definition Classes

   Nondeterminism

5. def aggregateCommutative[A](fs: Seq[Future[A]])(implicit arg0: Monoid[A]): Future[A]

   

   Definition Classes

   Nondeterminism

6. def all[A](fa: Future[A])(p: (A) ⇒ Boolean): Boolean

   

   Definition Classes

   Foldable

7. def allM[G[_], A](fa: Future[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

   

   Definition Classes

   Foldable

8. def any[A](fa: Future[A])(p: (A) ⇒ Boolean): Boolean

   

   Definition Classes

   Foldable

9. def anyM[G[_], A](fa: Future[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

   

   Definition Classes

   Foldable

10. def ap[A, B](fa: ⇒ Future[A])(f: ⇒ Future[(A) ⇒ B]): Future[B]

    

    Definition Classes

    FutureMonad → Bind → Apply

11. def ap(implicit F: Functor[Future]): Apply[Future]

    

    Definition Classes

    Zip

12. def ap2[A, B, C](fa: ⇒ Future[A], fb: ⇒ Future[B])(f: Future[(A, B) ⇒ C]): Future[C]

    

    Definition Classes

    Apply

13. def ap3[A, B, C, D](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C])(f: Future[(A, B, C) ⇒ D]): Future[D]

    

    Definition Classes

    Apply

14. def ap4[A, B, C, D, E](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D])(f: Future[(A, B, C, D) ⇒ E]): Future[E]

    

    Definition Classes

    Apply

15. def ap5[A, B, C, D, E, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E])(f: Future[(A, B, C, D, E) ⇒ R]): Future[R]

    

    Definition Classes

    Apply

16. def ap6[A, B, C, D, E, FF, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[FF])(f: Future[(A, B, C, D, E, FF) ⇒ R]): Future[R]

    

    Definition Classes

    Apply

17. def ap7[A, B, C, D, E, FF, G, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[FF], fg: ⇒ Future[G])(f: Future[(A, B, C, D, E, FF, G) ⇒ R]): Future[R]

    

    Definition Classes

    Apply

18. def ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[FF], fg: ⇒ Future[G], fh: ⇒ Future[H])(f: Future[(A, B, C, D, E, FF, G, H) ⇒ R]): Future[R]

    

    Definition Classes

    Apply

19. def apF[A, B](f: ⇒ Future[(A) ⇒ B]): (Future[A]) ⇒ Future[B]

    

    Definition Classes

    Apply

20. def applicativeLaw: ApplicativeLaw

    

    Definition Classes

    Applicative

21. val applicativePlusSyntax: ApplicativePlusSyntax[Future]

    

    Definition Classes

    ApplicativePlus

22. val applicativeSyntax: ApplicativeSyntax[[α]Future[α]]

    

    Definition Classes

    Applicative

23. def apply[A, B](fa: Future[A])(f: (A) ⇒ B): Future[B]

    

    Definition Classes

    Functor

24. def apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[FF], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J])(f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): Future[R]

    

    Definition Classes

    Apply

25. def apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[FF], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K])(f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): Future[R]

    

    Definition Classes

    Apply

26. def apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[FF], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I], fj: ⇒ Future[J], fk: ⇒ Future[K], fl: ⇒ Future[L])(f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): Future[R]

    

    Definition Classes

    Apply

27. def apply2[A, B, C](fa: ⇒ Future[A], fb: ⇒ Future[B])(f: (A, B) ⇒ C): Future[C]

    

    Definition Classes

    Applicative → Apply

28. def apply3[A, B, C, D](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C])(f: (A, B, C) ⇒ D): Future[D]

    

    Definition Classes

    Apply

29. def apply4[A, B, C, D, E](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D])(f: (A, B, C, D) ⇒ E): Future[E]

    

    Definition Classes

    Apply

30. def apply5[A, B, C, D, E, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E])(f: (A, B, C, D, E) ⇒ R): Future[R]

    

    Definition Classes

    Apply

31. def apply6[A, B, C, D, E, FF, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[FF])(f: (A, B, C, D, E, FF) ⇒ R): Future[R]

    

    Definition Classes

    Apply

32. def apply7[A, B, C, D, E, FF, G, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[FF], fg: ⇒ Future[G])(f: (A, B, C, D, E, FF, G) ⇒ R): Future[R]

    

    Definition Classes

    Apply

33. def apply8[A, B, C, D, E, FF, G, H, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[FF], fg: ⇒ Future[G], fh: ⇒ Future[H])(f: (A, B, C, D, E, FF, G, H) ⇒ R): Future[R]

    

    Definition Classes

    Apply

34. def apply9[A, B, C, D, E, FF, G, H, I, R](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E], ff: ⇒ Future[FF], fg: ⇒ Future[G], fh: ⇒ Future[H], fi: ⇒ Future[I])(f: (A, B, C, D, E, FF, G, H, I) ⇒ R): Future[R]

    

    Definition Classes

    Apply

35. def applyApplicative: Applicative[[α]\/[Future[α], α]]

    

    Definition Classes

    Apply

36. def applyLaw: ApplyLaw

    

    Definition Classes

    Apply

37. val applySyntax: ApplySyntax[[α]Future[α]]

    

    Definition Classes

    Apply

38. def apzip[A, B](f: ⇒ (Future[A]) ⇒ Future[B], a: ⇒ Future[A]): Future[(A, B)]

    

    Definition Classes

    Zip

39. def apzipPL[A, B](f: ⇒ @?>[Future[A], Future[B]], a: ⇒ Future[A])(implicit M: Monoid[Future[B]]): Future[(A, B)]

    

    Definition Classes

    Zip

40. final def asInstanceOf[T0]: T0

    

    Definition Classes

    Any

41. def async[A](pool: Executor)(a: ⇒ A): Future[A]

    

    Definition Classes

    FutureMonad → MonadAsync

42. def async[A](listen: Callback[A]): Future[A]

    
    returns

    an F whose value will be set from an asynchronous computation, via callback.

    Definition Classes

    FutureMonad → MonadAsync

43. def attempt[A](fa: Future[A]): Future[\/[Throwable, A]]

    

    Definition Classes

    FutureMonad → Catchable

44. def bicompose[G[_, _]](implicit arg0: Bitraverse[G]): Bitraverse[[α, β]Future[G[α, β]]]

    

    Definition Classes

    Traverse

45. def bicompose[G[_, _]](implicit arg0: Bifoldable[G]): Bifoldable[[a, b]Future[G[a, b]]]

    

    Definition Classes

    Foldable

46. def bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]Future[G[α, β]]]

    

    Definition Classes

    Functor

47. def bind[A, B](fa: Future[A])(f: (A) ⇒ Future[B]): Future[B]

    

    Definition Classes

    FutureMonad → Bind

48. def bindLaw: BindLaw

    

    Definition Classes

    Bind

49. val bindSyntax: BindSyntax[[α]Future[α]]

    

    Definition Classes

    Bind

50. def both[A, B](a: Future[A], b: Future[B]): Future[(A, B)]

    

    Definition Classes

    Nondeterminism

51. val catchableSyntax: CatchableSyntax[Future]

    

    Definition Classes

    Catchable

52. def choose[A, B](a: Future[A], b: Future[B]): Future[\/[(A, Future[B]), (Future[A], B)]]

    

    Definition Classes

    Nondeterminism

53. def chooseAny[A](head: Future[A], tail: Seq[Future[A]]): Future[(A, Seq[Future[A]])]

    

    Definition Classes

    FutureMonad → Nondeterminism

54. def chooseAny[A](a: Seq[Future[A]]): Option[Future[(A, Seq[Future[A]])]]

    

    Definition Classes

    Nondeterminism

55. def clone(): AnyRef

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

56. def cobind[A, B](fa: Future[A])(f: (Future[A]) ⇒ B): Future[B]

    

    Definition Classes

    FutureMonad → Cobind

57. def cobindLaw: CobindLaws

    

    Definition Classes

    Cobind

58. val cobindSyntax: CobindSyntax[Future]

    

    Definition Classes

    Cobind

59. def cojoin[A](fa: Future[A]): Future[Future[A]]

    

    Definition Classes

    Cobind

60. def collapse[X[_], A](x: Future[A])(implicit A: ApplicativePlus[X]): X[A]

    

    Definition Classes

    Foldable

61. def comonadLaw: ComonadLaws

    

    Definition Classes

    Comonad

62. val comonadSyntax: ComonadSyntax[Future]

    

    Definition Classes

    Comonad

63. def compose[G[_]](implicit G0: Traverse[G]): Traverse[[α]Future[G[α]]]

    

    Definition Classes

    Traverse

64. def compose[G[_]](implicit G0: Foldable[G]): Foldable[[α]Future[G[α]]]

    

    Definition Classes

    Foldable

65. def compose[G[_]](implicit T0: Functor[Future], G0: Zip[G]): Zip[[α]Future[G[α]]]

    

    Definition Classes

    Zip

66. def compose[G[_]](implicit G0: ApplicativePlus[G]): ApplicativePlus[[α]Future[G[α]]]

    

    Definition Classes

    ApplicativePlus

67. def compose[G[_]](implicit G0: PlusEmpty[G]): PlusEmpty[[α]Future[G[α]]]

    

    Definition Classes

    PlusEmpty

68. def compose[G[_]](implicit G0: Plus[G]): Plus[[α]Future[G[α]]]

    

    Definition Classes

    Plus

69. def compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]Future[G[α]]]

    

    Definition Classes

    Applicative

70. def compose[G[_]](implicit G0: Apply[G]): Apply[[α]Future[G[α]]]

    

    Definition Classes

    Apply

71. def compose[G[_]](implicit G0: Functor[G]): Functor[[α]Future[G[α]]]

    

    Definition Classes

    Functor

72. def copoint[A](p: Future[A]): A

    

    Definition Classes

    FutureMonad → Comonad

73. final def copure[A](p: Future[A]): A

    

    Definition Classes

    Comonad

74. final def count[A](fa: Future[A]): Int

    

    Definition Classes

    Foldable

75. def counzip[A, B](a: \/[Future[A], Future[B]]): Future[\/[A, B]]

    

    Definition Classes

    Functor

76. def delay[A](a: ⇒ A): Future[A]

    

    Definition Classes

    FutureMonad → MonadSuspend

77. def element[A](fa: Future[A], a: A)(implicit arg0: Equal[A]): Boolean

    

    Definition Classes

    Foldable

78. def empty[A]: Future[A]

    

    Definition Classes

    FutureMonad → PlusEmpty

79. def empty[A](fa: Future[A]): Boolean

    

    Definition Classes

    Foldable

80. final def eq(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

81. def equals(arg0: Any): Boolean

    

    Definition Classes

    AnyRef → Any

82. final def extend[A, B](fa: Future[A])(f: (Future[A]) ⇒ B): Future[B]

    

    Definition Classes

    Cobind

83. def fail[A](e: Throwable): Future[A]

    

    Definition Classes

    FutureMonad → Catchable

84. def filter[A](fa: Future[A])(f: (A) ⇒ Boolean): Future[A]

    

    Definition Classes

    FutureMonad → MonadPlus

85. def filterM[A](l: List[A])(f: (A) ⇒ Future[Boolean]): Future[List[A]]

    

    Definition Classes

    Applicative

86. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

87. def flip: Applicative[[α]Future[α]]

    

    Definition Classes

    Applicative

88. def fold[M](t: Future[M])(implicit arg0: Monoid[M]): M

    

    Definition Classes

    Foldable

89. def foldLShape[A, B](fa: Future[A], z: B)(f: (B, A) ⇒ B): (B, Future[Unit])

    

    Definition Classes

    Traverse

90. def foldLeft[A, B](fa: Future[A], z: B)(f: (B, A) ⇒ B): B

    

    Definition Classes

    Traverse → Foldable

91. def foldLeft1Opt[A](fa: Future[A])(f: (A, A) ⇒ A): Option[A]

    

    Definition Classes

    Foldable

92. def foldLeftM[G[_], A, B](fa: Future[A], z: B)(f: (B, A) ⇒ G[B])(implicit M: Monad[G]): G[B]

    

    Definition Classes

    Foldable

93. def foldMap[A, B](fa: Future[A])(f: (A) ⇒ B)(implicit F: Monoid[B]): B

    

    Definition Classes

    Traverse → Foldable

94. def foldMap1Opt[A, B](fa: Future[A])(f: (A) ⇒ B)(implicit F: Semigroup[B]): Option[B]

    

    Definition Classes

    Foldable

95. def foldMapLeft1Opt[A, B](fa: Future[A])(z: (A) ⇒ B)(f: (B, A) ⇒ B): Option[B]

    

    Definition Classes

    Foldable

96. def foldMapM[G[_], A, B](fa: Future[A])(f: (A) ⇒ G[B])(implicit B: Monoid[B], G: Monad[G]): G[B]

    

    Definition Classes

    Foldable

97. def foldMapRight1Opt[A, B](fa: Future[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): Option[B]

    

    Definition Classes

    Foldable

98. def foldRight[A, B](fa: Future[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ B): B

    

    Definition Classes

    Traverse → Foldable

99. def foldRight1Opt[A](fa: Future[A])(f: (A, ⇒ A) ⇒ A): Option[A]

    

    Definition Classes

    Foldable

100. def foldRightM[G[_], A, B](fa: Future[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]

     

     Definition Classes

     Foldable

101. def foldableLaw: FoldableLaw

     

     Definition Classes

     Foldable

102. val foldableSyntax: FoldableSyntax[Future]

     

     Definition Classes

     Foldable

103. final def foldl[A, B](fa: Future[A], z: B)(f: (B) ⇒ (A) ⇒ B): B

     

     Definition Classes

     Foldable

104. def foldl1Opt[A](fa: Future[A])(f: (A) ⇒ (A) ⇒ A): Option[A]

     

     Definition Classes

     Foldable

105. final def foldlM[G[_], A, B](fa: Future[A], z: ⇒ B)(f: (B) ⇒ (A) ⇒ G[B])(implicit M: Monad[G]): G[B]

     

     Definition Classes

     Foldable

106. final def foldr[A, B](fa: Future[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ B): B

     

     Definition Classes

     Foldable

107. def foldr1Opt[A](fa: Future[A])(f: (A) ⇒ (⇒ A) ⇒ A): Option[A]

     

     Definition Classes

     Foldable

108. final def foldrM[G[_], A, B](fa: Future[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]

     

     Definition Classes

     Foldable

109. def forever[A, B](fa: Future[A]): Future[B]

     

     Definition Classes

     Bind

110. def fpair[A](fa: Future[A]): Future[(A, A)]

     

     Definition Classes

     Functor

111. def fproduct[A, B](fa: Future[A])(f: (A) ⇒ B): Future[(A, B)]

     

     Definition Classes

     Functor

112. def functorLaw: FunctorLaw

     

     Definition Classes

     Functor

113. val functorSyntax: FunctorSyntax[[α]Future[α]]

     

     Definition Classes

     Functor

114. def gather[A](fs: Seq[Future[A]]): Future[List[A]]

     

     Definition Classes

     FutureMonad → Nondeterminism

115. def gatherUnordered[A](fs: Seq[Future[A]]): Future[List[A]]

     

     Definition Classes

     Nondeterminism

116. final def getClass(): Class[_]

     

     Definition Classes

     AnyRef → Any

117. def handleError[A](fa: Future[A])(f: (Throwable) ⇒ Future[A]): Future[A]

     

     Definition Classes

     FutureMonad → MonadError

118. def hashCode(): Int

     

     Definition Classes

     AnyRef → Any

119. def icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]Future[G[α]]]

     

     Definition Classes

     Functor

120. def ifM[B](value: Future[Boolean], ifTrue: ⇒ Future[B], ifFalse: ⇒ Future[B]): Future[B]

     

     Definition Classes

     Bind

121. def index[A](fa: Future[A], i: Int): Option[A]

     

     Definition Classes

     Foldable

122. def indexOr[A](fa: Future[A], default: ⇒ A, i: Int): A

     

     Definition Classes

     Foldable

123. def intercalate[A](fa: Future[A], a: A)(implicit A: Monoid[A]): A

     

     Definition Classes

     Foldable

124. def invariantFunctorLaw: InvariantFunctorLaw

     

     Definition Classes

     InvariantFunctor

125. val invariantFunctorSyntax: InvariantFunctorSyntax[[α]Future[α]]

     

     Definition Classes

     InvariantFunctor

126. final def isInstanceOf[T0]: Boolean

     

     Definition Classes

     Any

127. def iterateUntil[A](f: Future[A])(p: (A) ⇒ Boolean): Future[A]

     

     Definition Classes

     Monad

128. def iterateWhile[A](f: Future[A])(p: (A) ⇒ Boolean): Future[A]

     

     Definition Classes

     Monad

129. def join[A](ffa: Future[Future[A]]): Future[A]

     

     Definition Classes

     Bind

130. def length[A](fa: Future[A]): Int

     

     Definition Classes

     Foldable

131. def lift[A, B](f: (A) ⇒ B): (Future[A]) ⇒ Future[B]

     

     Definition Classes

     Functor

132. def lift10[A, B, C, D, E, FF, G, H, I, J, R](f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): (Future[A], Future[B], Future[C], Future[D], Future[E], Future[FF], Future[G], Future[H], Future[I], Future[J]) ⇒ Future[R]

     

     Definition Classes

     Apply

133. def lift11[A, B, C, D, E, FF, G, H, I, J, K, R](f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): (Future[A], Future[B], Future[C], Future[D], Future[E], Future[FF], Future[G], Future[H], Future[I], Future[J], Future[K]) ⇒ Future[R]

     

     Definition Classes

     Apply

134. def lift12[A, B, C, D, E, FF, G, H, I, J, K, L, R](f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): (Future[A], Future[B], Future[C], Future[D], Future[E], Future[FF], Future[G], Future[H], Future[I], Future[J], Future[K], Future[L]) ⇒ Future[R]

     

     Definition Classes

     Apply

135. def lift2[A, B, C](f: (A, B) ⇒ C): (Future[A], Future[B]) ⇒ Future[C]

     

     Definition Classes

     Apply

136. def lift3[A, B, C, D](f: (A, B, C) ⇒ D): (Future[A], Future[B], Future[C]) ⇒ Future[D]

     

     Definition Classes

     Apply

137. def lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (Future[A], Future[B], Future[C], Future[D]) ⇒ Future[E]

     

     Definition Classes

     Apply

138. def lift5[A, B, C, D, E, R](f: (A, B, C, D, E) ⇒ R): (Future[A], Future[B], Future[C], Future[D], Future[E]) ⇒ Future[R]

     

     Definition Classes

     Apply

139. def lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) ⇒ R): (Future[A], Future[B], Future[C], Future[D], Future[E], Future[FF]) ⇒ Future[R]

     

     Definition Classes

     Apply

140. def lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) ⇒ R): (Future[A], Future[B], Future[C], Future[D], Future[E], Future[FF], Future[G]) ⇒ Future[R]

     

     Definition Classes

     Apply

141. def lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) ⇒ R): (Future[A], Future[B], Future[C], Future[D], Future[E], Future[FF], Future[G], Future[H]) ⇒ Future[R]

     

     Definition Classes

     Apply

142. def lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) ⇒ R): (Future[A], Future[B], Future[C], Future[D], Future[E], Future[FF], Future[G], Future[H], Future[I]) ⇒ Future[R]

     

     Definition Classes

     Apply

143. def longDigits[A](fa: Future[A])(implicit d: <:<[A, Digit]): Long

     

     Definition Classes

     Foldable

144. def many[A](a: Future[A]): Future[List[A]]

     

     Definition Classes

     ApplicativePlus

145. def map[A, B](fa: Future[A])(f: (A) ⇒ B): Future[B]

     

     Definition Classes

     FutureMonad → Traverse → Monad → Applicative → Functor

146. def mapAccumL[S, A, B](fa: Future[A], z: S)(f: (S, A) ⇒ (S, B)): (S, Future[B])

     

     Definition Classes

     Traverse

147. def mapAccumR[S, A, B](fa: Future[A], z: S)(f: (S, A) ⇒ (S, B)): (S, Future[B])

     

     Definition Classes

     Traverse

148. def mapBoth[A, B, C](a: Future[A], b: Future[B])(f: (A, B) ⇒ C): Future[C]

     

     Definition Classes

     Nondeterminism

149. def mapply[A, B](a: A)(f: Future[(A) ⇒ B]): Future[B]

     

     Definition Classes

     Functor

150. def maximum[A](fa: Future[A])(implicit arg0: Order[A]): Option[A]

     

     Definition Classes

     Foldable

151. def maximumBy[A, B](fa: Future[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]

     

     Definition Classes

     Foldable

152. def maximumOf[A, B](fa: Future[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]

     

     Definition Classes

     Foldable

153. def minimum[A](fa: Future[A])(implicit arg0: Order[A]): Option[A]

     

     Definition Classes

     Foldable

154. def minimumBy[A, B](fa: Future[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]

     

     Definition Classes

     Foldable

155. def minimumOf[A, B](fa: Future[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]

     

     Definition Classes

     Foldable

156. def monadErrorLaw: MonadErrorLaw

     

     Definition Classes

     MonadError

157. val monadErrorSyntax: MonadErrorSyntax[[$qmark, α]Future[α], Throwable]

     

     Definition Classes

     MonadError

158. def monadLaw: MonadLaw

     

     Definition Classes

     Monad

159. def monadPlusLaw: MonadPlusLaw

     

     Definition Classes

     MonadPlus

160. val monadPlusSyntax: MonadPlusSyntax[Future]

     

     Definition Classes

     MonadPlus

161. val monadSyntax: MonadSyntax[[α]Future[α]]

     

     Definition Classes

     Monad

162. def monoid[A]: Monoid[Future[A]]

     

     Definition Classes

     PlusEmpty

163. final def ne(arg0: AnyRef): Boolean

     

     Definition Classes

     AnyRef

164. def nmap2[A, B, C](a: Future[A], b: Future[B])(f: (A, B) ⇒ C): Future[C]

     

     Definition Classes

     Nondeterminism

165. def nmap3[A, B, C, R](a: Future[A], b: Future[B], c: Future[C])(f: (A, B, C) ⇒ R): Future[R]

     

     Definition Classes

     Nondeterminism

166. def nmap4[A, B, C, D, R](a: Future[A], b: Future[B], c: Future[C], d: Future[D])(f: (A, B, C, D) ⇒ R): Future[R]

     

     Definition Classes

     Nondeterminism

167. def nmap5[A, B, C, D, E, R](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E])(f: (A, B, C, D, E) ⇒ R): Future[R]

     

     Definition Classes

     Nondeterminism

168. def nmap6[A, B, C, D, E, FF, R](a: Future[A], b: Future[B], c: Future[C], d: Future[D], e: Future[E], ff: Future[FF])(f: (A, B, C, D, E, FF) ⇒ R): Future[R]

     

     Definition Classes

     Nondeterminism

169. val nondeterminismSyntax: NondeterminismSyntax[Future]

     

     Definition Classes

     Nondeterminism

170. final def notify(): Unit

     

     Definition Classes

     AnyRef

171. final def notifyAll(): Unit

     

     Definition Classes

     AnyRef

172. def now[A](a: A): Future[A]

     

     Definition Classes

     FutureMonad → MonadSuspend

173. def plus[A](fa: Future[A], fb: ⇒ Future[A]): Future[A]

     

     Definition Classes

     FutureMonad → Plus

174. def plusEmptyLaw: EmptyLaw

     

     Definition Classes

     PlusEmpty

175. val plusEmptySyntax: PlusEmptySyntax[Future]

     

     Definition Classes

     PlusEmpty

176. def plusLaw: PlusLaw

     

     Definition Classes

     Plus

177. val plusSyntax: PlusSyntax[Future]

     

     Definition Classes

     Plus

178. def point[A](a: ⇒ A): Future[A]

     

     Definition Classes

     FutureMonad → Applicative

179. def product[G[_]](implicit G0: Traverse[G]): Traverse[[α](Future[α], G[α])]

     

     Definition Classes

     Traverse

180. def product[G[_]](implicit G0: Foldable[G]): Foldable[[α](Future[α], G[α])]

     

     Definition Classes

     Foldable

181. def product[G[_]](implicit G0: Zip[G]): Zip[[α](Future[α], G[α])]

     

     Definition Classes

     Zip

182. def product[G[_]](implicit G0: ApplicativePlus[G]): ApplicativePlus[[α](Future[α], G[α])]

     

     Definition Classes

     ApplicativePlus

183. def product[G[_]](implicit G0: PlusEmpty[G]): PlusEmpty[[α](Future[α], G[α])]

     

     Definition Classes

     PlusEmpty

184. def product[G[_]](implicit G0: Plus[G]): Plus[[α](Future[α], G[α])]

     

     Definition Classes

     Plus

185. def product[G[_]](implicit G0: Applicative[G]): Applicative[[α](Future[α], G[α])]

     

     Definition Classes

     Applicative

186. def product[G[_]](implicit G0: Apply[G]): Apply[[α](Future[α], G[α])]

     

     Definition Classes

     Apply

187. def product[G[_]](implicit G0: Functor[G]): Functor[[α](Future[α], G[α])]

     

     Definition Classes

     Functor

188. def product0[G[_]](implicit G0: Traverse1[G]): Traverse1[[α](Future[α], G[α])]

     

     Definition Classes

     Traverse

189. def product0[G[_]](implicit G0: Foldable1[G]): Foldable1[[α](Future[α], G[α])]

     

     Definition Classes

     Foldable

190. final def pure[A](a: ⇒ A): Future[A]

     

     Definition Classes

     Applicative

191. def raiseError[A](e: Throwable): Future[A]

     

     Definition Classes

     FutureMonad → MonadError

192. def reduceUnordered[A, M](fs: Seq[Future[A]])(implicit R: Reducer[A, M]): Future[M]

     

     Definition Classes

     Nondeterminism

193. def replicateM[A](n: Int, fa: Future[A]): Future[List[A]]

     

     Definition Classes

     Applicative

194. def replicateM_[A](n: Int, fa: Future[A]): Future[Unit]

     

     Definition Classes

     Applicative

195. def reverse[A](fa: Future[A]): Future[A]

     

     Definition Classes

     Traverse

196. def runTraverseS[S, A, B](fa: Future[A], s: S)(f: (A) ⇒ State[S, B]): (S, Future[B])

     

     Definition Classes

     Traverse

197. def selectSplit[A](fa: Future[A])(p: (A) ⇒ Boolean): List[NonEmptyList[A]]

     

     Definition Classes

     Foldable

198. def semigroup[A]: Semigroup[Future[A]]

     

     Definition Classes

     Plus

199. def separate[G[_, _], A, B](value: Future[G[A, B]])(implicit G: Bifoldable[G]): (Future[A], Future[B])

     

     Definition Classes

     MonadPlus

200. def sequence[G[_], A](fga: Future[G[A]])(implicit arg0: Applicative[G]): G[Future[A]]

     

     Definition Classes

     Traverse

201. def sequence[A, G[_]](as: G[Future[A]])(implicit arg0: Traverse[G]): Future[G[A]]

     

     Definition Classes

     Applicative

202. def sequence1[A, G[_]](as: G[Future[A]])(implicit arg0: Traverse1[G]): Future[G[A]]

     

     Definition Classes

     Apply

203. def sequenceF_[M[_], A](ffa: Future[Free[M, A]]): Free[M, Unit]

     

     Definition Classes

     Foldable

204. def sequenceS[S, A](fga: Future[State[S, A]]): State[S, Future[A]]

     

     Definition Classes

     Traverse

205. def sequenceS_[S, A](fga: Future[State[S, A]]): State[S, Unit]

     

     Definition Classes

     Foldable

206. final def sequenceU[A](self: Future[A])(implicit G: Unapply[Applicative, A]): M[Future[A]]

     

     Definition Classes

     Traverse

207. def sequence_[M[_], A](fa: Future[M[A]])(implicit a: Applicative[M]): M[Unit]

     

     Definition Classes

     Foldable

208. def some[A](a: Future[A]): Future[List[A]]

     

     Definition Classes

     ApplicativePlus

209. def splitWith[A](fa: Future[A])(p: (A) ⇒ Boolean): List[NonEmptyList[A]]

     

     Definition Classes

     Foldable

210. def strengthL[A, B](a: A, f: Future[B]): Future[(A, B)]

     

     Definition Classes

     Functor

211. def strengthR[A, B](f: Future[A], b: B): Future[(A, B)]

     

     Definition Classes

     Functor

212. def strongMonadPlusLaw: StrongMonadPlusLaw

     

     Definition Classes

     MonadPlus

213. def suspend[A](a: ⇒ Future[A]): Future[A]

     

     Definition Classes

     FutureMonad → MonadSuspend

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

     

     Definition Classes

     AnyRef

215. def to[A, G[_]](fa: Future[A])(implicit c: CanBuildFrom[Nothing, A, G[A]]): G[A]

     

     Definition Classes

     Foldable

216. def toEphemeralStream[A](fa: Future[A]): EphemeralStream[A]

     

     Definition Classes

     Foldable

217. def toIList[A](fa: Future[A]): IList[A]

     

     Definition Classes

     Foldable

218. def toIndexedSeq[A](fa: Future[A]): IndexedSeq[A]

     

     Definition Classes

     Foldable

219. def toList[A](fa: Future[A]): List[A]

     

     Definition Classes

     Foldable

220. def toSet[A](fa: Future[A]): Set[A]

     

     Definition Classes

     Foldable

221. def toStream[A](fa: Future[A]): Stream[A]

     

     Definition Classes

     Foldable

222. def toString(): String

     

     Definition Classes

     AnyRef → Any

223. def traversal[G[_]](implicit arg0: Applicative[G]): Traversal[G]

     

     Definition Classes

     Traverse

224. def traversalS[S]: Traversal[[x]IndexedStateT[[+X]X, S, S, x]]

     

     Definition Classes

     Traverse

225. def traverse[G[_], A, B](fa: Future[A])(f: (A) ⇒ G[B])(implicit arg0: Applicative[G]): G[Future[B]]

     

     Definition Classes

     Traverse

226. def traverse[A, G[_], B](value: G[A])(f: (A) ⇒ Future[B])(implicit G: Traverse[G]): Future[G[B]]

     

     Definition Classes

     Applicative

227. def traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ Future[B])(implicit G: Traverse1[G]): Future[G[B]]

     

     Definition Classes

     Apply

228. def traverseImpl[G[_], A, B](fa: Future[A])(f: (A) ⇒ G[B])(implicit arg0: Applicative[G]): G[Future[B]]

     

     Definition Classes

     FutureMonad → Traverse

229. def traverseKTrampoline[S, G[_], A, B](fa: Future[A])(f: (A) ⇒ Kleisli[G, S, B])(implicit arg0: Applicative[G]): Kleisli[G, S, Future[B]]

     

     Definition Classes

     Traverse

230. def traverseLaw: TraverseLaw

     

     Definition Classes

     Traverse

231. final def traverseM[A, G[_], B](fa: Future[A])(f: (A) ⇒ G[Future[B]])(implicit G: Applicative[G], F: Bind[Future]): G[Future[B]]

     

     Definition Classes

     Traverse

232. def traverseS[S, A, B](fa: Future[A])(f: (A) ⇒ State[S, B]): State[S, Future[B]]

     

     Definition Classes

     Traverse

233. def traverseSTrampoline[S, G[_], A, B](fa: Future[A])(f: (A) ⇒ State[S, G[B]])(implicit arg0: Applicative[G]): State[S, G[Future[B]]]

     

     Definition Classes

     Traverse

234. def traverseS_[S, A, B](fa: Future[A])(f: (A) ⇒ State[S, B]): State[S, Unit]

     

     Definition Classes

     Foldable

235. val traverseSyntax: TraverseSyntax[Future]

     

     Definition Classes

     Traverse

236. final def traverseU[A, GB](fa: Future[A])(f: (A) ⇒ GB)(implicit G: Unapply[Applicative, GB]): M[Future[A]]

     

     Definition Classes

     Traverse

237. final def traverseU_[A, GB](fa: Future[A])(f: (A) ⇒ GB)(implicit G: Unapply[Applicative, GB]): M[Unit]

     

     Definition Classes

     Foldable

238. def traverse_[M[_], A, B](fa: Future[A])(f: (A) ⇒ M[B])(implicit a: Applicative[M]): M[Unit]

     

     Definition Classes

     Foldable

239. def tuple2[A, B](fa: ⇒ Future[A], fb: ⇒ Future[B]): Future[(A, B)]

     

     Definition Classes

     Apply

240. def tuple3[A, B, C](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C]): Future[(A, B, C)]

     

     Definition Classes

     Apply

241. def tuple4[A, B, C, D](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D]): Future[(A, B, C, D)]

     

     Definition Classes

     Apply

242. def tuple5[A, B, C, D, E](fa: ⇒ Future[A], fb: ⇒ Future[B], fc: ⇒ Future[C], fd: ⇒ Future[D], fe: ⇒ Future[E]): Future[(A, B, C, D, E)]

     

     Definition Classes

     Apply

243. def unite[T[_], A](value: Future[T[A]])(implicit T: Foldable[T]): Future[A]

     

     Definition Classes

     MonadPlus

244. final def uniteU[T](value: Future[T])(implicit T: Unapply[Foldable, T]): Future[A]

     

     Definition Classes

     MonadPlus

245. def unlessM[A](cond: Boolean)(f: ⇒ Future[A]): Future[Unit]

     

     Definition Classes

     Applicative

246. def untilM[G[_], A](f: Future[A], cond: ⇒ Future[Boolean])(implicit G: MonadPlus[G]): Future[G[A]]

     

     Definition Classes

     Monad

247. def untilM_[A](f: Future[A], cond: ⇒ Future[Boolean]): Future[Unit]

     

     Definition Classes

     Monad

248. def void[A](fa: Future[A]): Future[Unit]

     

     Definition Classes

     Functor

249. final def wait(): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

251. final def wait(arg0: Long): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

252. def whenM[A](cond: Boolean)(f: ⇒ Future[A]): Future[Unit]

     

     Definition Classes

     Applicative

253. def whileM[G[_], A](p: Future[Boolean], body: ⇒ Future[A])(implicit G: MonadPlus[G]): Future[G[A]]

     

     Definition Classes

     Monad

254. def whileM_[A](p: Future[Boolean], body: ⇒ Future[A]): Future[Unit]

     

     Definition Classes

     Monad

255. def xmap[A, B](fa: Future[A], f: (A) ⇒ B, g: (B) ⇒ A): Future[B]

     

     Definition Classes

     Functor → InvariantFunctor

256. def xmapb[A, B](ma: Future[A])(b: scalaz.BijectionT.Bijection[A, B]): Future[B]

     

     Definition Classes

     InvariantFunctor

257. def xmapi[A, B](ma: Future[A])(iso: scalaz.Isomorphism.<=>[A, B]): Future[B]

     

     Definition Classes

     InvariantFunctor

258. def zip[A, B](a: ⇒ Future[A], b: ⇒ Future[B]): Future[(A, B)]

     

     Definition Classes

     FutureMonad → Zip

259. def zipL[A, B](fa: Future[A], fb: Future[B]): Future[(A, Option[B])]

     

     Definition Classes

     Traverse

260. def zipLaw: ZipLaw

     

     Definition Classes

     Zip

261. def zipR[A, B](fa: Future[A], fb: Future[B]): Future[(Option[A], B)]

     

     Definition Classes

     Traverse

262. val zipSyntax: ZipSyntax[Future]

     

     Definition Classes

     Zip

263. def zipWith[A, B, C](fa: Future[A], fb: Future[B])(f: (A, Option[B]) ⇒ C): (List[B], Future[C])

     

     Definition Classes

     Traverse

264. def zipWith[A, B, C](fa: ⇒ Future[A], fb: ⇒ Future[B])(f: (A, B) ⇒ C)(implicit F: Functor[Future]): Future[C]

     

     Definition Classes

     Zip

265. def zipWithL[A, B, C](fa: Future[A], fb: Future[B])(f: (A, Option[B]) ⇒ C): Future[C]

     

     Definition Classes

     Traverse

266. def zipWithR[A, B, C](fa: Future[A], fb: Future[B])(f: (Option[A], B) ⇒ C): Future[C]

     

     Definition Classes

     Traverse