# Packages

t

scalaz

Ordering
1. Alphabetic
2. By Inheritance
Inherited
2. IsomorphismApplicativePlus
3. IsomorphismPlusEmpty
4. IsomorphismPlus
6. IsomorphismBind
7. IsomorphismApplicative
8. IsomorphismInvariantApplicative
9. IsomorphismApply
10. IsomorphismFunctor
11. IsomorphismInvariantFunctor
13. ApplicativePlus
14. PlusEmpty
15. Plus
17. Bind
18. Applicative
19. InvariantApplicative
20. Apply
21. Functor
22. InvariantFunctor
23. AnyRef
24. Any
1. Hide All
2. Show All
Visibility
1. Public
2. All

### Type Members

1. trait ApplicativeLaw extends ApplyLaw
Definition Classes
Applicative
2. trait ApplyLaw extends FunctorLaw
Definition Classes
Apply
3. trait FlippedApply extends Apply[F]
Attributes
protected[this]
Definition Classes
Apply
4. trait BindLaw extends ApplyLaw
Definition Classes
Bind
5. trait FunctorLaw extends InvariantFunctorLaw
Definition Classes
Functor
6. trait InvariantFunctorLaw extends AnyRef
Definition Classes
InvariantFunctor
7. trait MonadLaw extends ApplicativeLaw with BindLaw
Definition Classes
Definition Classes
Definition Classes
10. trait PlusLaw extends AnyRef
Definition Classes
Plus
11. trait EmptyLaw extends PlusLaw
Definition Classes
PlusEmpty

### Abstract Value Members

1. implicit abstract def G: MonadPlus[G]
2. abstract def iso: Isomorphism.<~>[F, G]
Definition Classes
IsomorphismPlus

### Concrete Value Members

1. final def !=(arg0: Any)
Definition Classes
AnyRef → Any
2. final def ##(): Int
Definition Classes
AnyRef → Any
3. final def ==(arg0: Any)
Definition Classes
AnyRef → Any
4. def ap[A, B](fa: ⇒ F[A])(f: ⇒ F[(A) ⇒ B]): F[B]

Sequence `f`, then `fa`, combining their results by function application.

Sequence `f`, then `fa`, combining their results by function application.

NB: with respect to `apply2` and all other combinators, as well as scalaz.Bind, the `f` action appears to the *left*. So `f` should be the "first" `F`-action to perform. This is in accordance with all other implementations of this typeclass in common use, which are "function first".

Definition Classes
IsomorphismApplicativeIsomorphismApplyApply
5. def ap2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: F[(A, B) ⇒ C]): F[C]
Definition Classes
Apply
6. def ap3[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: F[(A, B, C) ⇒ D]): F[D]
Definition Classes
Apply
7. def ap4[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D])(f: F[(A, B, C, D) ⇒ E]): F[E]
Definition Classes
Apply
8. def ap5[A, B, C, D, E, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E])(f: F[(A, B, C, D, E) ⇒ R]): F[R]
Definition Classes
Apply
9. def ap6[A, B, C, D, E, FF, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF])(f: F[(A, B, C, D, E, FF) ⇒ R]): F[R]
Definition Classes
Apply
10. def ap7[A, B, C, D, E, FF, G, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G])(f: F[(A, B, C, D, E, FF, G) ⇒ R]): F[R]
Definition Classes
Apply
11. def ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H])(f: F[(A, B, C, D, E, FF, G, H) ⇒ R]): F[R]
Definition Classes
Apply
12. def apF[A, B](f: ⇒ F[(A) ⇒ B]): (F[A]) ⇒ F[B]

Flipped variant of `ap`.

Flipped variant of `ap`.

Definition Classes
Apply
13. def applicativeLaw
Definition Classes
Applicative
14. val applicativePlusSyntax
Definition Classes
ApplicativePlus
15. val applicativeSyntax
Definition Classes
Applicative
16. def apply[A, B](fa: F[A])(f: (A) ⇒ B): F[B]

Alias for `map`.

Alias for `map`.

Definition Classes
Functor
17. def apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J])(f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): F[R]
Definition Classes
Apply
18. def apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J], fk: ⇒ F[K])(f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): F[R]
Definition Classes
Apply
19. def apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J], fk: ⇒ F[K], fl: ⇒ F[L])(f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): F[R]
Definition Classes
Apply
20. def apply2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: (A, B) ⇒ C): F[C]
21. def apply3[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: (A, B, C) ⇒ D): F[D]
Definition Classes
Apply
22. def apply4[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D])(f: (A, B, C, D) ⇒ E): F[E]
Definition Classes
Apply
23. def apply5[A, B, C, D, E, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E])(f: (A, B, C, D, E) ⇒ R): F[R]
Definition Classes
Apply
24. def apply6[A, B, C, D, E, FF, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF])(f: (A, B, C, D, E, FF) ⇒ R): F[R]
Definition Classes
Apply
25. def apply7[A, B, C, D, E, FF, G, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G])(f: (A, B, C, D, E, FF, G) ⇒ R): F[R]
Definition Classes
Apply
26. def apply8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H])(f: (A, B, C, D, E, FF, G, H) ⇒ R): F[R]
Definition Classes
Apply
27. def apply9[A, B, C, D, E, FF, G, H, I, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I])(f: (A, B, C, D, E, FF, G, H, I) ⇒ R): F[R]
Definition Classes
Apply
28. def applyApplicative: Applicative[[α]\/[F[α], α]]

Add a unit to any Apply to form an Applicative.

Add a unit to any Apply to form an Applicative.

Definition Classes
Apply
29. def applyLaw
Definition Classes
Apply
30. val applySyntax: ApplySyntax[F]
Definition Classes
Apply
31. final def applying1[Z, A1](f: (A1) ⇒ Z)(implicit a1: F[A1]): F[Z]
Definition Classes
Apply
32. final def applying2[Z, A1, A2](f: (A1, A2) ⇒ Z)(implicit a1: F[A1], a2: F[A2]): F[Z]
Definition Classes
Apply
33. final def applying3[Z, A1, A2, A3](f: (A1, A2, A3) ⇒ Z)(implicit a1: F[A1], a2: F[A2], a3: F[A3]): F[Z]
Definition Classes
Apply
34. final def applying4[Z, A1, A2, A3, A4](f: (A1, A2, A3, A4) ⇒ Z)(implicit a1: F[A1], a2: F[A2], a3: F[A3], a4: F[A4]): F[Z]
Definition Classes
Apply
35. final def asInstanceOf[T0]: T0
Definition Classes
Any
36. def bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]F[G[α, β]]]

The composition of Functor `F` and Bifunctor `G`, `[x, y]F[G[x, y]]`, is a Bifunctor

The composition of Functor `F` and Bifunctor `G`, `[x, y]F[G[x, y]]`, is a Bifunctor

Definition Classes
Functor
37. def bind[A, B](fa: F[A])(f: (A) ⇒ F[B]): F[B]

Equivalent to `join(map(fa)(f))`.

Equivalent to `join(map(fa)(f))`.

Definition Classes
IsomorphismBindBind
38. def bindLaw
Definition Classes
Bind
39. val bindSyntax: BindSyntax[F]
Definition Classes
Bind
40. def clone()
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@native() @throws( ... )
41. def compose[G[_]](implicit G0: Applicative[G]): ApplicativePlus[[α]F[G[α]]]

The composition of ApplicativePlus `F` and Applicative `G`, `[x]F[G[x]]`, is a ApplicativePlus

The composition of ApplicativePlus `F` and Applicative `G`, `[x]F[G[x]]`, is a ApplicativePlus

Definition Classes
ApplicativePlusApplicative
42. def compose[G[_]]: PlusEmpty[[α]F[G[α]]]

The composition of PlusEmpty `F` and `G`, `[x]F[G[x]]`, is a PlusEmpty

The composition of PlusEmpty `F` and `G`, `[x]F[G[x]]`, is a PlusEmpty

Definition Classes
PlusEmptyPlus
43. def compose[G[_]](implicit G0: Apply[G]): Apply[[α]F[G[α]]]

The composition of Applys `F` and `G`, `[x]F[G[x]]`, is a Apply

The composition of Applys `F` and `G`, `[x]F[G[x]]`, is a Apply

Definition Classes
Apply
44. def compose[G[_]](implicit G0: Functor[G]): Functor[[α]F[G[α]]]

The composition of Functors `F` and `G`, `[x]F[G[x]]`, is a Functor

The composition of Functors `F` and `G`, `[x]F[G[x]]`, is a Functor

Definition Classes
Functor
45. def counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]
Definition Classes
Functor
46. def discardLeft[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[B]

Combine `fa` and `fb` according to `Apply[F]` with a function that discards the `A`(s)

Combine `fa` and `fb` according to `Apply[F]` with a function that discards the `A`(s)

Definition Classes
Apply
47. def discardRight[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[A]

Combine `fa` and `fb` according to `Apply[F]` with a function that discards the `B`(s)

Combine `fa` and `fb` according to `Apply[F]` with a function that discards the `B`(s)

Definition Classes
Apply
48. def empty[A]: F[A]
Definition Classes
IsomorphismPlusEmptyPlusEmpty
49. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
50. def equals(arg0: Any)
Definition Classes
AnyRef → Any
51. def filter[A](fa: F[A])(f: (A) ⇒ Boolean): F[A]

Remove `f`-failing `A`s in `fa`, by which we mean: in the expression `filter(filter(fa)(f))(g)`, `g` will never be invoked for any `a` where `f(a)` returns false.

Remove `f`-failing `A`s in `fa`, by which we mean: in the expression `filter(filter(fa)(f))(g)`, `g` will never be invoked for any `a` where `f(a)` returns false.

Definition Classes
52. def filterM[A](l: IList[A])(f: (A) ⇒ F[Boolean]): F[IList[A]]

Filter `l` according to an applicative predicate.

Filter `l` according to an applicative predicate.

Definition Classes
Applicative
53. def filterM[A](l: List[A])(f: (A) ⇒ F[Boolean]): F[List[A]]

Filter `l` according to an applicative predicate.

Filter `l` according to an applicative predicate.

Definition Classes
Applicative
54. def finalize(): Unit
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
55. def flip: Applicative[F]

An `Applicative` for `F` in which effects happen in the opposite order.

An `Applicative` for `F` in which effects happen in the opposite order.

Definition Classes
ApplicativeApply
56. def forever[A, B](fa: F[A]): F[B]

Repeats an applicative action infinitely

Repeats an applicative action infinitely

Definition Classes
Apply
57. def fpair[A](fa: F[A]): F[(A, A)]

Twin all `A`s in `fa`.

Twin all `A`s in `fa`.

Definition Classes
Functor
58. def fproduct[A, B](fa: F[A])(f: (A) ⇒ B): F[(A, B)]

Pair all `A`s in `fa` with the result of function application.

Pair all `A`s in `fa` with the result of function application.

Definition Classes
Functor
59. def functorLaw
Definition Classes
Functor
60. val functorSyntax: FunctorSyntax[F]
Definition Classes
Functor
61. final def getClass(): Class[_]
Definition Classes
AnyRef → Any
Annotations
@native()
62. def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
63. def icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]F[G[α]]]

The composition of Functor F and Contravariant G, `[x]F[G[x]]`, is contravariant.

The composition of Functor F and Contravariant G, `[x]F[G[x]]`, is contravariant.

Definition Classes
Functor
64. def ifM[B](value: F[Boolean], ifTrue: ⇒ F[B], ifFalse: ⇒ F[B]): F[B]

`if` lifted into a binding.

`if` lifted into a binding. Unlike ```lift3((t,c,a)=>if(t)c else a)```, this will only include context from the chosen of `ifTrue` and `ifFalse`, not the other.

Definition Classes
Bind
65. val invariantApplicativeSyntax
Definition Classes
InvariantApplicative
66. def invariantFunctorLaw
Definition Classes
InvariantFunctor
67. val invariantFunctorSyntax
Definition Classes
InvariantFunctor
68. final def isInstanceOf[T0]
Definition Classes
Any
69. def iterateUntil[A](f: F[A])(p: (A) ⇒ Boolean): F[A]

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result satisfies the given predicate and return that result, discarding all others.

Definition Classes
70. def iterateWhile[A](f: F[A])(p: (A) ⇒ Boolean): F[A]

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Execute an action repeatedly until its result fails to satisfy the given predicate and return that result, discarding all others.

Definition Classes
71. def join[A](ffa: F[F[A]]): F[A]

Sequence the inner `F` of `FFA` after the outer `F`, forming a single `F[A]`.

Sequence the inner `F` of `FFA` after the outer `F`, forming a single `F[A]`.

Definition Classes
Bind
72. def lefts[G[_, _], A, B](value: F[G[A, B]])(implicit G: Bifoldable[G]): F[A]

Generalized version of Haskell's `lefts`

Generalized version of Haskell's `lefts`

Definition Classes
73. def lift[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[B]

Lift `f` into `F`.

Lift `f` into `F`.

Definition Classes
Functor
74. 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): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J]) ⇒ F[R]
Definition Classes
Apply
75. 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): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J], F[K]) ⇒ F[R]
Definition Classes
Apply
76. 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): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J], F[K], F[L]) ⇒ F[R]
Definition Classes
Apply
77. def lift2[A, B, C](f: (A, B) ⇒ C): (F[A], F[B]) ⇒ F[C]
Definition Classes
Apply
78. def lift3[A, B, C, D](f: (A, B, C) ⇒ D): (F[A], F[B], F[C]) ⇒ F[D]
Definition Classes
Apply
79. def lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (F[A], F[B], F[C], F[D]) ⇒ F[E]
Definition Classes
Apply
80. def lift5[A, B, C, D, E, R](f: (A, B, C, D, E) ⇒ R): (F[A], F[B], F[C], F[D], F[E]) ⇒ F[R]
Definition Classes
Apply
81. def lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF]) ⇒ F[R]
Definition Classes
Apply
82. def lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G]) ⇒ F[R]
Definition Classes
Apply
83. def lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H]) ⇒ F[R]
Definition Classes
Apply
84. def lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I]) ⇒ F[R]
Definition Classes
Apply
85. def liftReducer[A, B](implicit r: Reducer[A, B]): Reducer[F[A], F[B]]
Definition Classes
Apply
86. def map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]

Lift `f` into `F` and apply to `F[A]`.

Lift `f` into `F` and apply to `F[A]`.

Definition Classes
IsomorphismFunctorFunctor
87. def mapply[A, B](a: A)(f: F[(A) ⇒ B]): F[B]

Lift `apply(a)`, and apply the result to `f`.

Lift `apply(a)`, and apply the result to `f`.

Definition Classes
Functor
Definition Classes
Definition Classes
Definition Classes
Definition Classes
92. def monoid[A]: Monoid[F[A]]
Definition Classes
PlusEmpty
93. def mproduct[A, B](fa: F[A])(f: (A) ⇒ F[B]): F[(A, B)]

Pair `A` with the result of function application.

Pair `A` with the result of function application.

Definition Classes
Bind
94. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
95. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
96. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
97. def par: Par[F]

A lawful implementation of this that is isomorphic up to the methods defined on Applicative allowing for optimised parallel implementations that would otherwise violate laws of more specific typeclasses (e.g.

A lawful implementation of this that is isomorphic up to the methods defined on Applicative allowing for optimised parallel implementations that would otherwise violate laws of more specific typeclasses (e.g. Monad).

Definition Classes
Applicative
98. def plus[A](a: F[A], b: ⇒ F[A]): F[A]
Definition Classes
IsomorphismPlusPlus
99. def plusA[A](x: ⇒ F[A], y: ⇒ F[A])(implicit sa: Semigroup[A]): F[A]

Semigroups can be added within an Applicative

Semigroups can be added within an Applicative

Definition Classes
Applicative
100. def plusEmptyLaw
Definition Classes
PlusEmpty
101. val plusEmptySyntax: PlusEmptySyntax[F]
Definition Classes
PlusEmpty
102. def plusLaw
Definition Classes
Plus
103. val plusSyntax: PlusSyntax[F]
Definition Classes
Plus
104. def point[A](a: ⇒ A): F[A]
Definition Classes
IsomorphismApplicativeApplicative

The product of MonadPlus `F` and `G`, `[x](F[x], G[x]])`, is a MonadPlus

The product of MonadPlus `F` and `G`, `[x](F[x], G[x]])`, is a MonadPlus

Definition Classes
106. def product[G[_]](implicit G0: ApplicativePlus[G]): ApplicativePlus[[α](F[α], G[α])]

The product of ApplicativePlus `F` and `G`, `[x](F[x], G[x]])`, is a ApplicativePlus

The product of ApplicativePlus `F` and `G`, `[x](F[x], G[x]])`, is a ApplicativePlus

Definition Classes
ApplicativePlus
107. def product[G[_]](implicit G0: PlusEmpty[G]): PlusEmpty[[α](F[α], G[α])]

The product of PlusEmpty `F` and `G`, `[x](F[x], G[x]])`, is a PlusEmpty

The product of PlusEmpty `F` and `G`, `[x](F[x], G[x]])`, is a PlusEmpty

Definition Classes
PlusEmpty
108. def product[G[_]](implicit G0: Plus[G]): Plus[[α](F[α], G[α])]

The product of Plus `F` and `G`, `[x](F[x], G[x]])`, is a Plus

The product of Plus `F` and `G`, `[x](F[x], G[x]])`, is a Plus

Definition Classes
Plus

The product of Monad `F` and `G`, `[x](F[x], G[x]])`, is a Monad

The product of Monad `F` and `G`, `[x](F[x], G[x]])`, is a Monad

Definition Classes
110. def product[G[_]](implicit G0: Bind[G]): Bind[[α](F[α], G[α])]

The product of Bind `F` and `G`, `[x](F[x], G[x]])`, is a Bind

The product of Bind `F` and `G`, `[x](F[x], G[x]])`, is a Bind

Definition Classes
Bind
111. def product[G[_]](implicit G0: Applicative[G]): Applicative[[α](F[α], G[α])]

The product of Applicatives `F` and `G`, `[x](F[x], G[x]])`, is an Applicative

The product of Applicatives `F` and `G`, `[x](F[x], G[x]])`, is an Applicative

Definition Classes
Applicative
112. def product[G[_]](implicit G0: Apply[G]): Apply[[α](F[α], G[α])]

The product of Applys `F` and `G`, `[x](F[x], G[x]])`, is a Apply

The product of Applys `F` and `G`, `[x](F[x], G[x]])`, is a Apply

Definition Classes
Apply
113. def product[G[_]](implicit G0: Functor[G]): Functor[[α](F[α], G[α])]

The product of Functors `F` and `G`, `[x](F[x], G[x]])`, is a Functor

The product of Functors `F` and `G`, `[x](F[x], G[x]])`, is a Functor

Definition Classes
Functor
114. final def pure[A](a: ⇒ A): F[A]
Definition Classes
Applicative
115. def replicateM[A](n: Int, fa: F[A]): F[IList[A]]

Performs the action `n` times, returning the list of results.

Performs the action `n` times, returning the list of results.

Definition Classes
Applicative
116. def replicateM_[A](n: Int, fa: F[A]): F[Unit]

Performs the action `n` times, returning nothing.

Performs the action `n` times, returning nothing.

Definition Classes
Applicative
117. def rights[G[_, _], A, B](value: F[G[A, B]])(implicit G: Bifoldable[G]): F[B]

Generalized version of Haskell's `rights`

Generalized version of Haskell's `rights`

Definition Classes
118. def semigroup[A]: Semigroup[F[A]]
Definition Classes
Plus
119. def separate[G[_, _], A, B](value: F[G[A, B]])(implicit G: Bifoldable[G]): (F[A], F[B])

Generalized version of Haskell's `partitionEithers`

Generalized version of Haskell's `partitionEithers`

Definition Classes
120. def sequence[A, G[_]](as: G[F[A]])(implicit arg0: Traverse[G]): F[G[A]]
Definition Classes
Applicative
121. def sequence1[A, G[_]](as: G[F[A]])(implicit arg0: Traverse1[G]): F[G[A]]
Definition Classes
Apply
122. def strengthL[A, B](a: A, f: F[B]): F[(A, B)]

Inject `a` to the left of `B`s in `f`.

Inject `a` to the left of `B`s in `f`.

Definition Classes
Functor
123. def strengthR[A, B](f: F[A], b: B): F[(A, B)]

Inject `b` to the right of `A`s in `f`.

Inject `b` to the right of `A`s in `f`.

Definition Classes
Functor
Definition Classes
125. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
126. def toString()
Definition Classes
AnyRef → Any
127. def traverse[A, G[_], B](value: G[A])(f: (A) ⇒ F[B])(implicit G: Traverse[G]): F[G[B]]
Definition Classes
Applicative
128. def traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ F[B])(implicit G: Traverse1[G]): F[G[B]]
Definition Classes
Apply
129. def tuple2[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[(A, B)]
Definition Classes
Apply
130. def tuple3[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C]): F[(A, B, C)]
Definition Classes
Apply
131. def tuple4[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D]): F[(A, B, C, D)]
Definition Classes
Apply
132. def tuple5[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E]): F[(A, B, C, D, E)]
Definition Classes
Apply
133. def unfoldlPsum[S, A](seed: S)(f: (S) ⇒ Maybe[(S, F[A])]): F[A]
Definition Classes
PlusEmpty
134. def unfoldlPsumOpt[S, A](seed: S)(f: (S) ⇒ Maybe[(S, F[A])]): Maybe[F[A]]

Unfold `seed` to the left and sum using #plus.

Unfold `seed` to the left and sum using #plus. `Plus` instances with right absorbing elements may override this method to not unfold more than is necessary to determine the result.

Definition Classes
Plus
135. def unfoldrOpt[S, A, B](seed: S)(f: (S) ⇒ Maybe[(F[A], S)])(implicit R: Reducer[A, B]): Maybe[F[B]]

Unfold `seed` to the right and combine effects left-to-right, using the given Reducer to combine values.

Unfold `seed` to the right and combine effects left-to-right, using the given Reducer to combine values. Implementations may override this method to not unfold more than is necessary to determine the result.

Definition Classes
Apply
136. def unfoldrPsum[S, A](seed: S)(f: (S) ⇒ Maybe[(F[A], S)]): F[A]
Definition Classes
PlusEmpty
137. def unfoldrPsumOpt[S, A](seed: S)(f: (S) ⇒ Maybe[(F[A], S)]): Maybe[F[A]]

Unfold `seed` to the right and sum using #plus.

Unfold `seed` to the right and sum using #plus. `Plus` instances with left absorbing elements may override this method to not unfold more than is necessary to determine the result.

Definition Classes
Plus
138. def unite[T[_], A](value: F[T[A]])(implicit T: Foldable[T]): F[A]

Generalized version of Haskell's `catMaybes`

Generalized version of Haskell's `catMaybes`

Definition Classes
139. final def uniteU[T](value: F[T])(implicit T: Unapply[Foldable, T]): F[A]

A version of `unite` that infers the type constructor `T`.

A version of `unite` that infers the type constructor `T`.

Definition Classes
140. def unlessM[A](cond: Boolean)(f: ⇒ F[A]): F[Unit]

Returns the given argument if `cond` is `false`, otherwise, unit lifted into F.

Returns the given argument if `cond` is `false`, otherwise, unit lifted into F.

Definition Classes
Applicative
141. def untilM[G[_], A](f: F[A], cond: ⇒ F[Boolean])(implicit G: MonadPlus[G]): F[G[A]]

Execute an action repeatedly until the `Boolean` condition returns `true`.

Execute an action repeatedly until the `Boolean` condition returns `true`. The condition is evaluated after the loop body. Collects results into an arbitrary `MonadPlus` value, such as a `List`.

Definition Classes
142. def untilM_[A](f: F[A], cond: ⇒ F[Boolean]): F[Unit]

Execute an action repeatedly until the `Boolean` condition returns `true`.

Execute an action repeatedly until the `Boolean` condition returns `true`. The condition is evaluated after the loop body. Discards results.

Definition Classes
143. def void[A](fa: F[A]): F[Unit]

Empty `fa` of meaningful pure values, preserving its structure.

Empty `fa` of meaningful pure values, preserving its structure.

Definition Classes
Functor
144. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
145. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
146. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@native() @throws( ... )
147. def whenM[A](cond: Boolean)(f: ⇒ F[A]): F[Unit]

Returns the given argument if `cond` is `true`, otherwise, unit lifted into F.

Returns the given argument if `cond` is `true`, otherwise, unit lifted into F.

Definition Classes
Applicative
148. def whileM[G[_], A](p: F[Boolean], body: ⇒ F[A])(implicit G: MonadPlus[G]): F[G[A]]

Execute an action repeatedly as long as the given `Boolean` expression returns `true`.

Execute an action repeatedly as long as the given `Boolean` expression returns `true`. The condition is evalated before the loop body. Collects the results into an arbitrary `MonadPlus` value, such as a `List`.

Definition Classes
149. def whileM_[A](p: F[Boolean], body: ⇒ F[A]): F[Unit]

Execute an action repeatedly as long as the given `Boolean` expression returns `true`.

Execute an action repeatedly as long as the given `Boolean` expression returns `true`. The condition is evaluated before the loop body. Discards results.

Definition Classes
150. def widen[A, B](fa: F[A])(implicit ev: <~<[A, B]): F[B]

Functors are covariant by nature, so we can treat an `F[A]` as an `F[B]` if `A` is a subtype of `B`.

Functors are covariant by nature, so we can treat an `F[A]` as an `F[B]` if `A` is a subtype of `B`.

Definition Classes
Functor
151. final def xderiving0[Z](z: ⇒ Z): F[Z]
Definition Classes
InvariantApplicative
152. final def xderiving1[Z, A1](f: (A1) ⇒ Z, g: (Z) ⇒ A1)(implicit a1: F[A1]): F[Z]
Definition Classes
InvariantApplicative
153. final def xderiving2[Z, A1, A2](f: (A1, A2) ⇒ Z, g: (Z) ⇒ (A1, A2))(implicit a1: F[A1], a2: F[A2]): F[Z]
Definition Classes
InvariantApplicative
154. final def xderiving3[Z, A1, A2, A3](f: (A1, A2, A3) ⇒ Z, g: (Z) ⇒ (A1, A2, A3))(implicit a1: F[A1], a2: F[A2], a3: F[A3]): F[Z]
Definition Classes
InvariantApplicative
155. final def xderiving4[Z, A1, A2, A3, A4](f: (A1, A2, A3, A4) ⇒ Z, g: (Z) ⇒ (A1, A2, A3, A4))(implicit a1: F[A1], a2: F[A2], a3: F[A3], a4: F[A4]): F[Z]
Definition Classes
InvariantApplicative
156. def xmap[A, B](ma: F[A], f: (A) ⇒ B, g: (B) ⇒ A): F[B]

Converts `ma` to a value of type `F[B]` using the provided functions `f` and `g`.

Converts `ma` to a value of type `F[B]` using the provided functions `f` and `g`.

Definition Classes
IsomorphismInvariantFunctorInvariantFunctor
157. def xmapb[A, B](ma: F[A])(b: Bijection[A, B]): F[B]

Converts `ma` to a value of type `F[B]` using the provided bijection.

Converts `ma` to a value of type `F[B]` using the provided bijection.

Definition Classes
InvariantFunctor
158. def xmapi[A, B](ma: F[A])(iso: Isomorphism.<=>[A, B]): F[B]

Converts `ma` to a value of type `F[B]` using the provided isomorphism.

Converts `ma` to a value of type `F[B]` using the provided isomorphism.

Definition Classes
InvariantFunctor
159. def xproduct0[Z](z: ⇒ Z): F[Z]
160. def xproduct1[Z, A1](a1: ⇒ F[A1])(f: (A1) ⇒ Z, g: (Z) ⇒ A1): F[Z]
161. def xproduct2[Z, A1, A2](a1: ⇒ F[A1], a2: ⇒ F[A2])(f: (A1, A2) ⇒ Z, g: (Z) ⇒ (A1, A2)): F[Z]
162. def xproduct3[Z, A1, A2, A3](a1: ⇒ F[A1], a2: ⇒ F[A2], a3: ⇒ F[A3])(f: (A1, A2, A3) ⇒ Z, g: (Z) ⇒ (A1, A2, A3)): F[Z]
163. def xproduct4[Z, A1, A2, A3, A4](a1: ⇒ F[A1], a2: ⇒ F[A2], a3: ⇒ F[A3], a4: ⇒ F[A4])(f: (A1, A2, A3, A4) ⇒ Z, g: (Z) ⇒ (A1, A2, A3, A4)): F[Z]