t

scalaz

# Traverse 

### Companion object Traverse

#### trait Traverse[F[_]] extends Functor[F] with Foldable[F] with TraverseParent[F]

Idiomatic traversal of a structure, as described in The Essence of the Iterator Pattern.

Self Type
Traverse[F]
Source
Traverse.scala

scalaz.Traverse.TraverseLaw

Linear Supertypes
Known Subclasses
Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. Traverse
2. TraverseParent
3. Foldable
4. FoldableParent
5. Functor
6. InvariantFunctor
7. AnyRef
8. Any
1. Hide All
2. Show All
Visibility
1. Public
2. All

### Type Members

1. trait FoldableLaw extends AnyRef
Definition Classes
Foldable
2. trait FunctorLaw extends InvariantFunctorLaw
Definition Classes
Functor
3. trait InvariantFunctorLaw extends AnyRef
Definition Classes
InvariantFunctor
4. class Traversal[G[_]] extends AnyRef
5. trait TraverseLaw extends FunctorLaw

### Abstract Value Members

1. abstract def traverseImpl[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit arg0: Applicative[G]): G[F[B]]

Transform `fa` using `f`, collecting all the `G`s with `ap`.

### 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 all[A](fa: F[A])(p: (A) ⇒ Boolean)

Whether all `A`s in `fa` yield true from `p`.

Whether all `A`s in `fa` yield true from `p`.

Definition Classes
Foldable
5. def allM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

`all` with monadic traversal.

`all` with monadic traversal.

Definition Classes
Foldable
6. def any[A](fa: F[A])(p: (A) ⇒ Boolean)

Whether any `A`s in `fa` yield true from `p`.

Whether any `A`s in `fa` yield true from `p`.

Definition Classes
Foldable
7. def anyM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

`any` with monadic traversal.

`any` with monadic traversal.

Definition Classes
Foldable
8. def apply[A, B](fa: F[A])(f: (A) ⇒ B): F[B]

Alias for `map`.

Alias for `map`.

Definition Classes
Functor
9. final def asInstanceOf[T0]: T0
Definition Classes
Any
10. def bicompose[G[_, _]](implicit arg0: Bitraverse[G]): Bitraverse[[α, β]F[G[α, β]]]

The composition of Traverse `F` and Bitraverse `G`, `[x, y]F[G[x, y]]`, is a Bitraverse

11. def bicompose[G[_, _]](implicit arg0: Bifoldable[G]): Bifoldable[[α, β]F[G[α, β]]]

The composition of Foldable `F` and Bifoldable `G`, `[x, y]F[G[x, y]]`, is a Bifoldable

The composition of Foldable `F` and Bifoldable `G`, `[x, y]F[G[x, y]]`, is a Bifoldable

Definition Classes
Foldable
12. 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
13. def clone()
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
14. def collapse[X[_], A](x: F[A])(implicit A: ApplicativePlus[X]): X[A]
Definition Classes
Foldable
15. def compose[G[_]](implicit G0: Traverse[G]): Traverse[[α]F[G[α]]]

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

16. def compose[G[_]](implicit G0: Foldable[G]): Foldable[[α]F[G[α]]]

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

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

Definition Classes
Foldable
17. 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
18. final def count[A](fa: F[A]): Int

Alias for `length`.

Alias for `length`.

Definition Classes
Foldable
19. def counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]
Definition Classes
Functor
20. def distinct[A](fa: F[A])(implicit A: Order[A]): IList[A]

`O(n log n)` complexity

`O(n log n)` complexity

Definition Classes
Foldable
21. def distinctBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[A]
Definition Classes
FoldableParent
22. def distinctE[A](fa: F[A])(implicit A: Equal[A]): IList[A]

`O(n2)` complexity

`O(n2)` complexity

Definition Classes
Foldable
23. def element[A](fa: F[A], a: A)(implicit arg0: Equal[A])

Whether `a` is an element of `fa`.

Whether `a` is an element of `fa`.

Definition Classes
Foldable
24. def empty[A](fa: F[A])

Deforested alias for `toStream(fa).isEmpty`.

Deforested alias for `toStream(fa).isEmpty`.

Definition Classes
Foldable
25. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
26. def equals(arg0: Any)
Definition Classes
AnyRef → Any
27. def extrema[A](fa: F[A])(implicit arg0: Order[A]): Option[(A, A)]

The smallest and largest elements of `fa` or None if `fa` is empty

The smallest and largest elements of `fa` or None if `fa` is empty

Definition Classes
FoldableParent
28. def extremaBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[(A, A)]

The elements (amin, amax) of `fa` which yield the smallest and largest values of `f(a)`, respectively, or None if `fa` is empty

The elements (amin, amax) of `fa` which yield the smallest and largest values of `f(a)`, respectively, or None if `fa` is empty

Definition Classes
FoldableParent
29. def extremaOf[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[(B, B)]

The smallest and largest values of `f(a)` for each element `a` of `fa` , or None if `fa` is empty

The smallest and largest values of `f(a)` for each element `a` of `fa` , or None if `fa` is empty

Definition Classes
FoldableParent
30. def filterLength[A](fa: F[A])(f: (A) ⇒ Boolean): Int
Definition Classes
FoldableParent
31. def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
32. def findLeft[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]
Definition Classes
Foldable
33. final def findMapM[M[_], A, B](fa: F[A])(f: (A) ⇒ M[Option[B]])(implicit arg0: Monad[M]): M[Option[B]]

map elements in a Foldable with a monadic function and return the first element that is mapped successfully

map elements in a Foldable with a monadic function and return the first element that is mapped successfully

Definition Classes
Foldable
34. def findRight[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]
Definition Classes
Foldable
35. def fold[M](t: F[M])(implicit arg0: Monoid[M]): M

Combine the elements of a structure using a monoid.

Combine the elements of a structure using a monoid.

Definition Classes
Foldable
36. def fold1Opt[A](fa: F[A])(implicit arg0: Semigroup[A]): Option[A]

Like `fold` but returning `None` if the foldable is empty and `Some` otherwise

Like `fold` but returning `None` if the foldable is empty and `Some` otherwise

Definition Classes
FoldableParent
37. def foldLShape[A, B](fa: F[A], z: B)(f: (B, A) ⇒ B): (B, F[Unit])
38. def foldLeft[A, B](fa: F[A], z: B)(f: (B, A) ⇒ B): B

Left-associative fold of a structure.

Left-associative fold of a structure.

Definition Classes
TraverseFoldable
39. def foldLeft1Opt[A](fa: F[A])(f: (A, A) ⇒ A): Option[A]
Definition Classes
Foldable
40. def foldLeftM[G[_], A, B](fa: F[A], z: B)(f: (B, A) ⇒ G[B])(implicit M: Monad[G]): G[B]

Left-associative, monadic fold of a structure.

Left-associative, monadic fold of a structure.

Definition Classes
Foldable
41. def foldMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Monoid[B]): B

Map each element of the structure to a scalaz.Monoid, and combine the results.

Map each element of the structure to a scalaz.Monoid, and combine the results.

Definition Classes
TraverseFoldable
42. def foldMap1Opt[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Semigroup[B]): Option[B]

As `foldMap` but returning `None` if the foldable is empty and `Some` otherwise

As `foldMap` but returning `None` if the foldable is empty and `Some` otherwise

Definition Classes
Foldable
43. def foldMapLeft1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (B, A) ⇒ B): Option[B]
Definition Classes
Foldable
44. def foldMapM[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit B: Monoid[B], G: Monad[G]): G[B]

Specialization of foldRightM when `B` has a `Monoid`.

Specialization of foldRightM when `B` has a `Monoid`.

Definition Classes
Foldable
45. def foldMapRight1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): Option[B]
Definition Classes
Foldable
46. def foldRight[A, B](fa: F[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ B): B

Right-associative fold of a structure.

Right-associative fold of a structure.

Definition Classes
TraverseFoldable
47. def foldRight1Opt[A](fa: F[A])(f: (A, ⇒ A) ⇒ A): Option[A]
Definition Classes
Foldable
48. def foldRightM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]

Right-associative, monadic fold of a structure.

Right-associative, monadic fold of a structure.

Definition Classes
Foldable
49. def foldableLaw
Definition Classes
Foldable
50. val foldableSyntax: FoldableSyntax[F]
Definition Classes
Foldable
51. final def foldl[A, B](fa: F[A], z: B)(f: (B) ⇒ (A) ⇒ B): B

Curried version of `foldLeft`

Curried version of `foldLeft`

Definition Classes
Foldable
52. def foldl1Opt[A](fa: F[A])(f: (A) ⇒ (A) ⇒ A): Option[A]
Definition Classes
Foldable
53. final def foldlM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (B) ⇒ (A) ⇒ G[B])(implicit M: Monad[G]): G[B]

Curried version of `foldLeftM`

Curried version of `foldLeftM`

Definition Classes
Foldable
54. final def foldr[A, B](fa: F[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ B): B

Curried version of `foldRight`

Curried version of `foldRight`

Definition Classes
Foldable
55. def foldr1Opt[A](fa: F[A])(f: (A) ⇒ (⇒ A) ⇒ A): Option[A]
Definition Classes
Foldable
56. final def foldrM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]

Curried version of `foldRightM`

Curried version of `foldRightM`

Definition Classes
Foldable
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 index[A](fa: F[A], i: Int): Option[A]

returns

the element at index `i` in a `Some`, or `None` if the given index falls outside of the range

Definition Classes
Foldable
65. def indexOr[A](fa: F[A], default: ⇒ A, i: Int): A

returns

the element at index `i`, or `default` if the given index falls outside of the range

Definition Classes
Foldable
66. def indexed[A](fa: F[A]): F[(Int, A)]
67. def intercalate[A](fa: F[A], a: A)(implicit A: Monoid[A]): A

Insert an `A` between every A, yielding the sum.

Insert an `A` between every A, yielding the sum.

Definition Classes
Foldable
68. def invariantFunctorLaw
Definition Classes
InvariantFunctor
69. val invariantFunctorSyntax
Definition Classes
InvariantFunctor
70. final def isInstanceOf[T0]
Definition Classes
Any
71. def length[A](fa: F[A]): Int

Deforested alias for `toStream(fa).size`.

Deforested alias for `toStream(fa).size`.

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

Lift `f` into `F`.

Lift `f` into `F`.

Definition Classes
Functor
73. def longDigits[A](fa: F[A])(implicit d: <:<[A, Digit]): Long
Definition Classes
Foldable
74. 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
TraverseFunctor
75. def mapAccumL[S, A, B](fa: F[A], z: S)(f: (S, A) ⇒ (S, B)): (S, F[B])
76. def mapAccumR[S, A, B](fa: F[A], z: S)(f: (S, A) ⇒ (S, B)): (S, F[B])
77. 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
78. def maximum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]

The greatest element of `fa`, or None if `fa` is empty.

The greatest element of `fa`, or None if `fa` is empty.

Definition Classes
Foldable
79. def maximumBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]

The element `a` of `fa` which yields the greatest value of `f(a)`, or None if `fa` is empty.

The element `a` of `fa` which yields the greatest value of `f(a)`, or None if `fa` is empty.

Definition Classes
Foldable
80. def maximumOf[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]

The greatest value of `f(a)` for each element `a` of `fa`, or None if `fa` is empty.

The greatest value of `f(a)` for each element `a` of `fa`, or None if `fa` is empty.

Definition Classes
Foldable
81. def minimum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]

The smallest element of `fa`, or None if `fa` is empty.

The smallest element of `fa`, or None if `fa` is empty.

Definition Classes
Foldable
82. def minimumBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]

The element `a` of `fa` which yields the smallest value of `f(a)`, or None if `fa` is empty.

The element `a` of `fa` which yields the smallest value of `f(a)`, or None if `fa` is empty.

Definition Classes
Foldable
83. def minimumOf[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]

The smallest value of `f(a)` for each element `a` of `fa`, or None if `fa` is empty.

The smallest value of `f(a)` for each element `a` of `fa`, or None if `fa` is empty.

Definition Classes
Foldable
84. def msuml[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]
Definition Classes
Foldable
85. def msumlU[GA](fa: F[GA])(implicit G: Unapply[PlusEmpty, GA]): M[A]
Definition Classes
FoldableParent
86. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
87. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
88. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
89. def product[G[_]](implicit G0: Traverse[G]): Traverse[[α](F[α], G[α])]

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

90. def product[G[_]](implicit G0: Foldable[G]): Foldable[[α](F[α], G[α])]

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

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

Definition Classes
Foldable
91. 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
92. def product0[G[_]](implicit G0: Traverse1[G]): Traverse1[[α](F[α], G[α])]

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

93. def product0[G[_]](implicit G0: Foldable1[G]): Foldable1[[α](F[α], G[α])]

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

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

Definition Classes
Foldable
94. def reverse[A](fa: F[A]): F[A]
95. def runTraverseS[S, A, B](fa: F[A], s: S)(f: (A) ⇒ State[S, B]): (S, F[B])
96. def selectSplit[A](fa: F[A])(p: (A) ⇒ Boolean): List[NonEmptyList[A]]

Selects groups of elements that satisfy p and discards others.

Selects groups of elements that satisfy p and discards others.

Definition Classes
Foldable
97. def sequence[G[_], A](fga: F[G[A]])(implicit arg0: Applicative[G]): G[F[A]]

Traverse with the identity function.

98. def sequenceF_[M[_], A](ffa: F[Free[M, A]]): Free[M, Unit]

`sequence_` for Free.

`sequence_` for Free. collapses into a single Free *

Definition Classes
Foldable
99. def sequenceM[A, G[_]](fgfa: F[G[F[A]]])(implicit G: Applicative[G], F: Bind[F]): G[F[A]]

A version of `sequence` where a subsequent monadic join is applied to the inner result

A version of `sequence` where a subsequent monadic join is applied to the inner result

Definition Classes
TraverseParent
100. def sequenceS[S, A](fga: F[State[S, A]]): State[S, F[A]]

Traverse with `State`.

101. def sequenceS_[S, A](fga: F[State[S, A]]): State[S, Unit]

`sequence_` specialized to `State` *

`sequence_` specialized to `State` *

Definition Classes
Foldable
102. final def sequenceU[A](self: F[A])(implicit G: Unapply[Applicative, A]): M[F[A]]

A version of `sequence` that infers the nested type constructor.

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

Strict sequencing in an applicative functor `M` that ignores the value in `fa`.

Strict sequencing in an applicative functor `M` that ignores the value in `fa`.

Definition Classes
Foldable
104. def splitBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[(B, NonEmptyList[A])]

Splits the elements into groups that produce the same result by a function f.

Splits the elements into groups that produce the same result by a function f.

Definition Classes
FoldableParent
105. def splitByRelation[A](fa: F[A])(r: (A, A) ⇒ Boolean): IList[NonEmptyList[A]]

Splits into groups of elements that are transitively dependant by a relation r.

Splits into groups of elements that are transitively dependant by a relation r.

Definition Classes
FoldableParent
106. def splitWith[A](fa: F[A])(p: (A) ⇒ Boolean): List[NonEmptyList[A]]

Splits the elements into groups that alternatively satisfy and don't satisfy the predicate p.

Splits the elements into groups that alternatively satisfy and don't satisfy the predicate p.

Definition Classes
Foldable
107. 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
108. 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
109. def suml[A](fa: F[A])(implicit A: Monoid[A]): A
Definition Classes
Foldable
110. def suml1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
Definition Classes
Foldable
111. def sumr[A](fa: F[A])(implicit A: Monoid[A]): A
Definition Classes
Foldable
112. def sumr1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
Definition Classes
Foldable
113. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
114. def toEphemeralStream[A](fa: F[A]): EphemeralStream[A]
Definition Classes
Foldable
115. def toIList[A](fa: F[A]): IList[A]
Definition Classes
Foldable
116. def toList[A](fa: F[A]): List[A]
Definition Classes
Foldable
117. def toSet[A](fa: F[A]): Set[A]
Definition Classes
Foldable
118. def toStream[A](fa: F[A]): Stream[A]
Definition Classes
Foldable
119. def toString()
Definition Classes
AnyRef → Any
120. def toVector[A](fa: F[A]): Vector[A]
Definition Classes
Foldable
121. def traversal[G[_]](implicit arg0: Applicative[G]): Traversal[G]
122. def traversalS[S]: Traversal[[β\$0\$]IndexedStateT[[X]X, S, S, β\$0\$]]
123. def traverse[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit arg0: Applicative[G]): G[F[B]]
124. def traverseKTrampoline[S, G[_], A, B](fa: F[A])(f: (A) ⇒ Kleisli[G, S, B])(implicit arg0: Applicative[G]): Kleisli[G, S, F[B]]

Traverse `fa` with a `Kleisli[G, S, B]`, internally using a `Trampoline` to avoid stack overflow.

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

A version of `traverse` where a subsequent monadic join is applied to the inner result.

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

Traverse with `State`.

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

Traverse `fa` with a `State[S, G[B]]`, internally using a `Trampoline` to avoid stack overflow.

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

`traverse_` specialized to `State` *

`traverse_` specialized to `State` *

Definition Classes
Foldable
130. val traverseSyntax: TraverseSyntax[F]
131. final def traverseU[A, GB](fa: F[A])(f: (A) ⇒ GB)(implicit G: Unapply[Applicative, GB]): M[F[A]]

A version of `traverse` that infers the type constructor `G`.

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

A version of `traverse_` that infers the type constructor `M`.

A version of `traverse_` that infers the type constructor `M`.

Definition Classes
Foldable
133. def traverse_[M[_], A, B](fa: F[A])(f: (A) ⇒ M[B])(implicit a: Applicative[M]): M[Unit]

Strict traversal in an applicative functor `M` that ignores the result of `f`.

Strict traversal in an applicative functor `M` that ignores the result of `f`.

Definition Classes
Foldable
134. 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
135. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
136. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
137. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
138. 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
139. 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
140. 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
141. 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
142. def zipL[A, B](fa: F[A], fb: F[B]): F[(A, Option[B])]
143. def zipR[A, B](fa: F[A], fb: F[B]): F[(Option[A], B)]
144. def zipWith[A, B, C](fa: F[A], fb: F[B])(f: (A, Option[B]) ⇒ C): (List[B], F[C])
145. def zipWithL[A, B, C](fa: F[A], fb: F[B])(f: (A, Option[B]) ⇒ C): F[C]
146. def zipWithR[A, B, C](fa: F[A], fb: F[B])(f: (Option[A], B) ⇒ C): F[C]

### Deprecated Value Members

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

Definition Classes
Foldable
Annotations
@deprecated
Deprecated

(Since version 7.2.22) removed in scalaz 7.3

Exceptions thrown

`NoSuchMethodException` if Scala 2.13 or later