t

scalaz

# IsomorphismNondeterminism 

#### trait IsomorphismNondeterminism[F[_], G[_]] extends Nondeterminism[F] with IsomorphismMonad[F, G]

Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. IsomorphismNondeterminism
3. IsomorphismBind
4. IsomorphismApplicative
5. IsomorphismApply
6. IsomorphismFunctor
7. Nondeterminism
9. Bind
10. BindParent
11. Applicative
12. ApplicativeParent
13. Apply
14. ApplyParent
15. Functor
16. InvariantFunctor
17. AnyRef
18. 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 BindLaw extends ApplyLaw
Definition Classes
Bind
4. trait FunctorLaw extends InvariantFunctorLaw
Definition Classes
Functor
5. trait InvariantFunctorLaw extends AnyRef
Definition Classes
InvariantFunctor
6. trait MonadLaw extends ApplicativeLaw with BindLaw
Definition Classes

### Abstract Value Members

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

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

Nondeterministically sequence `fs`, collecting the results using a `Monoid`.

Nondeterministically sequence `fs`, collecting the results using a `Monoid`.

Definition Classes
Nondeterminism
5. def aggregate1[A](fs: NonEmptyList[F[A]])(implicit arg0: Semigroup[A]): F[A]
Definition Classes
Nondeterminism
6. def aggregateCommutative[A](fs: Seq[F[A]])(implicit arg0: Monoid[A]): F[A]

Nondeterministically sequence `fs`, collecting the results using a commutative `Monoid`.

Nondeterministically sequence `fs`, collecting the results using a commutative `Monoid`.

Definition Classes
Nondeterminism
7. def aggregateCommutative1[A](fs: NonEmptyList[F[A]])(implicit arg0: Semigroup[A]): F[A]
Definition Classes
Nondeterminism
8. 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
9. def ap2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: F[(A, B) ⇒ C]): F[C]
Definition Classes
Apply
10. 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
11. 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
12. 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
13. 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
14. 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
15. 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
16. def apF[A, B](f: ⇒ F[(A) ⇒ B]): (F[A]) ⇒ F[B]

Flipped variant of `ap`.

Flipped variant of `ap`.

Definition Classes
Apply
17. def applicativeLaw
Definition Classes
Applicative
18. val applicativeSyntax
Definition Classes
Applicative
19. def apply[A, B](fa: F[A])(f: (A) ⇒ B): F[B]

Alias for `map`.

Alias for `map`.

Definition Classes
Functor
20. 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
21. 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
22. 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
23. def apply2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: (A, B) ⇒ C): F[C]
Definition Classes
IsomorphismApplicativeApplicativeApply
24. 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
25. 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
26. 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
27. 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
28. 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
29. 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
30. 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
31. 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
32. def applyLaw
Definition Classes
Apply
33. val applySyntax: ApplySyntax[F]
Definition Classes
Apply
34. final def asInstanceOf[T0]: T0
Definition Classes
Any
35. 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
36. 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
37. def bindLaw
Definition Classes
Bind
38. val bindSyntax: BindSyntax[F]
Definition Classes
Bind
39. def both[A, B](a: F[A], b: F[B]): F[(A, B)]

Obtain results from both `a` and `b`, nondeterministically ordering their effects.

Obtain results from both `a` and `b`, nondeterministically ordering their effects.

Definition Classes
Nondeterminism
40. def choose[A, B](a: F[A], b: F[B]): F[\/[(A, F[B]), (F[A], B)]]

A commutative operation which chooses nondeterministically to obtain a value from either `a` or `b`.

A commutative operation which chooses nondeterministically to obtain a value from either `a` or `b`. If `a` 'wins', a 'residual' context for `b` is returned; if `b` wins, a residual context for `a` is returned. The residual is useful for various instances like `Future`, which may race the two computations and require a residual to ensure the result of the 'losing' computation is not discarded.

This function can be defined in terms of `chooseAny` or vice versa. The default implementation calls `chooseAny` with a two-element list and uses the `Functor` for `F` to fix up types.

Definition Classes
Nondeterminism
41. def chooseAny[A](head: F[A], tail: Seq[F[A]]): F[(A, Seq[F[A]])]
42. def chooseAny[A](a: Seq[F[A]]): Option[F[(A, Seq[F[A]])]]

A commutative operation which chooses nondeterministically to obtain a value from any of the elements of `as`.

A commutative operation which chooses nondeterministically to obtain a value from any of the elements of `as`. In the language of posets, this constructs an antichain (a set of elements which are all incomparable) in the effect poset for this computation.

returns

`None`, if the input is empty.

Definition Classes
Nondeterminism
43. def clone()
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
44. def compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]F[G[α]]]

The composition of Applicatives `F` and `G`, `[x]F[G[x]]`, is an Applicative

The composition of Applicatives `F` and `G`, `[x]F[G[x]]`, is an Applicative

Definition Classes
Applicative
45. 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
46. 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
47. def counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]
Definition Classes
Functor
48. 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
ApplyParent
49. 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
ApplyParent
50. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
51. def equals(arg0: Any)
Definition Classes
AnyRef → Any
52. 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
53. def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
54. 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
ApplicativeApplyParent
55. def forever[A, B](fa: F[A]): F[B]

Repeats a monadic action infinitely

Repeats a monadic action infinitely

Definition Classes
BindApplyParent
56. def fpair[A](fa: F[A]): F[(A, A)]

Twin all `A`s in `fa`.

Twin all `A`s in `fa`.

Definition Classes
Functor
57. 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
58. def functorLaw
Definition Classes
Functor
59. val functorSyntax: FunctorSyntax[F]
Definition Classes
Functor
60. def gather[A](fs: Seq[F[A]]): F[List[A]]

Nondeterministically gather results from the given sequence of actions.

Nondeterministically gather results from the given sequence of actions. 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`.

Definition Classes
Nondeterminism
61. def gather1[A](fs: NonEmptyList[F[A]]): F[NonEmptyList[A]]
Definition Classes
Nondeterminism
62. def gatherUnordered[A](fs: Seq[F[A]]): F[List[A]]

Nondeterministically gather results from the given sequence of actions to a list.

Nondeterministically gather results from the given sequence of actions to a list. Same as calling `reduceUnordered` with the `List` `Monoid`.

To preserve the order of the output list while allowing nondetermininstic ordering of effects, use `gather`.

Definition Classes
Nondeterminism
63. def gatherUnordered1[A](fs: NonEmptyList[F[A]]): F[NonEmptyList[A]]
Definition Classes
Nondeterminism
64. final def getClass(): Class[_]
Definition Classes
AnyRef → Any
Annotations
@native()
65. def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
66. 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
67. 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
68. def invariantFunctorLaw
Definition Classes
InvariantFunctor
69. val invariantFunctorSyntax
Definition Classes
InvariantFunctor
70. final def isInstanceOf[T0]
Definition Classes
Any
71. 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
72. 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
73. 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
74. def lift[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[B]

Lift `f` into `F`.

Lift `f` into `F`.

Definition Classes
Functor
75. 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
76. 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
77. 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
78. def lift2[A, B, C](f: (A, B) ⇒ C): (F[A], F[B]) ⇒ F[C]
Definition Classes
Apply
79. def lift3[A, B, C, D](f: (A, B, C) ⇒ D): (F[A], F[B], F[C]) ⇒ F[D]
Definition Classes
Apply
80. 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
81. 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
82. 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
83. 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
84. 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
85. 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
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 mapBoth[A, B, C](a: F[A], b: F[B])(f: (A, B) ⇒ C): F[C]

Apply a function to the results of `a` and `b`, nondeterminstically ordering their effects.

Apply a function to the results of `a` and `b`, nondeterminstically ordering their effects.

Definition Classes
Nondeterminism
88. 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
91. 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
92. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
93. def nmap2[A, B, C](a: F[A], b: F[B])(f: (A, B) ⇒ C): F[C]

Apply a function to 2 results, nondeterminstically ordering their effects, alias of mapBoth

Apply a function to 2 results, nondeterminstically ordering their effects, alias of mapBoth

Definition Classes
Nondeterminism
94. def nmap3[A, B, C, R](a: F[A], b: F[B], c: F[C])(f: (A, B, C) ⇒ R): F[R]

Apply a function to 3 results, nondeterminstically ordering their effects

Apply a function to 3 results, nondeterminstically ordering their effects

Definition Classes
Nondeterminism
95. def nmap4[A, B, C, D, R](a: F[A], b: F[B], c: F[C], d: F[D])(f: (A, B, C, D) ⇒ R): F[R]

Apply a function to 4 results, nondeterminstically ordering their effects

Apply a function to 4 results, nondeterminstically ordering their effects

Definition Classes
Nondeterminism
96. def nmap5[A, B, C, D, E, R](a: F[A], b: F[B], c: F[C], d: F[D], e: F[E])(f: (A, B, C, D, E) ⇒ R): F[R]

Apply a function to 5 results, nondeterminstically ordering their effects

Apply a function to 5 results, nondeterminstically ordering their effects

Definition Classes
Nondeterminism
97. def nmap6[A, B, C, D, E, FF, R](a: F[A], b: F[B], c: F[C], d: F[D], e: F[E], ff: F[FF])(f: (A, B, C, D, E, FF) ⇒ R): F[R]

Apply a function to 6 results, nondeterminstically ordering their effects

Apply a function to 6 results, nondeterminstically ordering their effects

Definition Classes
Nondeterminism
98. val nondeterminismSyntax
Definition Classes
Nondeterminism
99. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
100. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
101. 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
ApplicativeParent
102. def parallel: Applicative[[α][F[α], Parallel]]
Definition Classes
Nondeterminism
103. def point[A](a: ⇒ A): F[A]
Definition Classes
IsomorphismApplicativeApplicative
104. def product[G[_]](implicit G0: Monad[G]): Monad[[α](F[α], G[α])]

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
105. 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
106. 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
107. 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
108. 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
109. final def pure[A](a: ⇒ A): F[A]
Definition Classes
Applicative
110. def reduceUnordered[A, M](fs: Seq[F[A]])(implicit R: Reducer[A, M]): F[M]

Nondeterministically gather results from the given sequence of actions.

Nondeterministically gather results from the given sequence of actions. The result will be arbitrarily reordered, depending on the order results come back in a sequence of calls to `chooseAny`.

Definition Classes
Nondeterminism
111. def replicateM[A](n: Int, fa: F[A]): F[List[A]]

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

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

Definition Classes
Applicative
112. 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
113. def sequence[A, G[_]](as: G[F[A]])(implicit arg0: Traverse[G]): F[G[A]]
Definition Classes
Applicative
114. def sequence1[A, G[_]](as: G[F[A]])(implicit arg0: Traverse1[G]): F[G[A]]
Definition Classes
Apply
115. 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
116. 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
117. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
118. def toString()
Definition Classes
AnyRef → Any
119. def traverse[A, G[_], B](value: G[A])(f: (A) ⇒ F[B])(implicit G: Traverse[G]): F[G[B]]
Definition Classes
Applicative
120. def traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ F[B])(implicit G: Traverse1[G]): F[G[B]]
Definition Classes
Apply
121. def tuple2[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[(A, B)]
Definition Classes
Apply
122. def tuple3[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C]): F[(A, B, C)]
Definition Classes
Apply
123. 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
124. 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
125. 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
126. 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
127. 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
128. 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
129. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
130. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
131. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
132. 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
133. 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
134. 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
135. 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
136. def xmap[A, B](fa: 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
FunctorInvariantFunctor
137. 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
138. 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