t

scalaz

# IsomorphismTraverse1 

#### trait IsomorphismTraverse1[F[_], G[_]] extends Traverse1[F] with IsomorphismTraverse[F, G] with IsomorphismFoldable1[F, G]

Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. IsomorphismTraverse1
2. IsomorphismFoldable1
3. IsomorphismTraverse
4. IsomorphismFunctor
5. IsomorphismFoldable
6. Traverse1
7. Foldable1
8. Traverse
9. TraverseParent
10. Foldable
11. FoldableParent
12. Functor
13. InvariantFunctor
14. AnyRef
15. Any
1. Hide All
2. Show All
Visibility
1. Public
2. All

### Type Members

1. trait FoldableLaw extends AnyRef
Definition Classes
Foldable
2. trait Foldable1Law extends FoldableLaw
Definition Classes
Foldable1
3. trait FunctorLaw extends InvariantFunctorLaw
Definition Classes
Functor
4. trait InvariantFunctorLaw extends AnyRef
Definition Classes
InvariantFunctor
5. class Traversal[G[_]] extends AnyRef
Definition Classes
Traverse
6. trait TraverseLaw extends FunctorLaw
Definition Classes
Traverse
7. trait Traverse1Law extends TraverseLaw
Definition Classes
Traverse1

### Abstract Value Members

1. implicit abstract def G: Traverse1[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 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

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

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

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

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

Definition Classes
Traverse1
16. def compose[G[_]](implicit arg0: Foldable1[G]): Foldable1[[α]F[G[α]]]

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

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

Definition Classes
Foldable1
17. def compose[G[_]](implicit G0: Traverse[G]): Traverse[[α]F[G[α]]]

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

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

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

Alias for `length`.

Alias for `length`.

Definition Classes
Foldable
21. def counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]
Definition Classes
Functor
22. 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
23. def distinct1[A](fa: F[A])(implicit A: Order[A]): NonEmptyList[A]

`O(n log n)` complexity

`O(n log n)` complexity

Definition Classes
Foldable1
24. def distinctBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[A]
Definition Classes
FoldableParent
25. def distinctE[A](fa: F[A])(implicit A: Equal[A]): IList[A]

`O(n2)` complexity

`O(n2)` complexity

Definition Classes
Foldable
26. def distinctE1[A](fa: F[A])(implicit A: Equal[A]): NonEmptyList[A]

`O(n2)` complexity

`O(n2)` complexity

Definition Classes
Foldable1
27. 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
28. final def empty[A](fa: F[A])

always return `false`

always return `false`

Definition Classes
Foldable1Foldable
29. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
30. def equals(arg0: Any)
Definition Classes
AnyRef → Any
31. 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
32. 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
33. 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
34. def filterLength[A](fa: F[A])(f: (A) ⇒ Boolean): Int
Definition Classes
FoldableParent
35. def finalize(): Unit
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
36. def findLeft[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]
Definition Classes
Foldable
37. 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
38. def findRight[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]
Definition Classes
Foldable
39. 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
40. def fold1[M](t: F[M])(implicit arg0: Semigroup[M]): M
Definition Classes
Foldable1
41. 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
42. def foldLShape[A, B](fa: F[A], z: B)(f: (B, A) ⇒ B): (B, F[Unit])
Definition Classes
Traverse
43. 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
IsomorphismFoldableFoldable
44. def foldLeft1[A](fa: F[A])(f: (A, A) ⇒ A): A

Left-associative fold of a structure.

Left-associative fold of a structure.

Definition Classes
Foldable1
45. def foldLeft1Opt[A](fa: F[A])(f: (A, A) ⇒ A): Option[A]
Definition Classes
Foldable
46. 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
47. 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
IsomorphismFoldableFoldable
48. final def foldMap1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Semigroup[B]): B

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

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

Definition Classes
IsomorphismFoldable1Foldable1
49. 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
Foldable1Foldable
50. final def foldMapLeft1[A, B](fa: F[A])(z: (A) ⇒ B)(f: (B, A) ⇒ B): B

Left-associative fold of a structure.

Left-associative fold of a structure.

Definition Classes
IsomorphismFoldable1Foldable1
51. def foldMapLeft1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (B, A) ⇒ B): Option[B]
Definition Classes
Foldable1Foldable
52. 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
53. final def foldMapRight1[A, B](fa: F[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): B

Right-associative fold of a structure.

Right-associative fold of a structure.

Definition Classes
IsomorphismFoldable1Foldable1
54. def foldMapRight1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): Option[B]
Definition Classes
Foldable1Foldable
55. 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
IsomorphismFoldableFoldable
56. def foldRight1[A](fa: F[A])(f: (A, ⇒ A) ⇒ A): A

Right-associative fold of a structure.

Right-associative fold of a structure.

Definition Classes
Foldable1
57. def foldRight1Opt[A](fa: F[A])(f: (A, ⇒ A) ⇒ A): Option[A]
Definition Classes
Foldable
58. 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
59. def foldable1Law
Definition Classes
Foldable1
60. val foldable1Syntax: Foldable1Syntax[F]
Definition Classes
Foldable1
61. def foldableLaw
Definition Classes
Foldable
62. val foldableSyntax: FoldableSyntax[F]
Definition Classes
Foldable
63. 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
64. final def foldl1[A](fa: F[A])(f: (A) ⇒ (A) ⇒ A): A

Curried `foldLeft1`.

Curried `foldLeft1`.

Definition Classes
Foldable1
65. def foldl1Opt[A](fa: F[A])(f: (A) ⇒ (A) ⇒ A): Option[A]
Definition Classes
Foldable1Foldable
66. 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
67. 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
68. final def foldr1[A](fa: F[A])(f: (A) ⇒ (⇒ A) ⇒ A): A

Curried `foldRight1`.

Curried `foldRight1`.

Definition Classes
Foldable1
69. def foldr1Opt[A](fa: F[A])(f: (A) ⇒ (⇒ A) ⇒ A): Option[A]
Definition Classes
Foldable1Foldable
70. 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
71. def fpair[A](fa: F[A]): F[(A, A)]

Twin all `A`s in `fa`.

Twin all `A`s in `fa`.

Definition Classes
Functor
72. 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
73. def functorLaw
Definition Classes
Functor
74. val functorSyntax: FunctorSyntax[F]
Definition Classes
Functor
75. final def getClass(): Class[_]
Definition Classes
AnyRef → Any
Annotations
@native()
76. def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
77. 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
78. 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
79. 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
80. def indexed[A](fa: F[A]): F[(Int, A)]
Definition Classes
Traverse
81. def intercalate[A](fa: F[A], a: A)(implicit arg0: Monoid[A]): A

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

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

Definition Classes
Foldable1Foldable
82. def intercalate1[A](fa: F[A], a: A)(implicit A: Semigroup[A]): A

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

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

Definition Classes
Foldable1
83. def invariantFunctorLaw
Definition Classes
InvariantFunctor
84. val invariantFunctorSyntax
Definition Classes
InvariantFunctor
85. final def isInstanceOf[T0]
Definition Classes
Any
86. def length[A](fa: F[A]): Int

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

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

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

Lift `f` into `F`.

Lift `f` into `F`.

Definition Classes
Functor
88. def longDigits[A](fa: F[A])(implicit d: <:<[A, Digit]): Long
Definition Classes
Foldable
89. 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
90. def mapAccumL[S, A, B](fa: F[A], z: S)(f: (S, A) ⇒ (S, B)): (S, F[B])
Definition Classes
Traverse
91. def mapAccumR[S, A, B](fa: F[A], z: S)(f: (S, A) ⇒ (S, B)): (S, F[B])
Definition Classes
Traverse
92. 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
93. 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
Foldable1Foldable
94. def maximum1[A](fa: F[A])(implicit arg0: Order[A]): A

The greatest element of `fa`.

The greatest element of `fa`.

Definition Classes
Foldable1
95. 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
Foldable1Foldable
96. def maximumBy1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): A

The element `a` of `fa` which yield the greatest value of `f(a)`.

The element `a` of `fa` which yield the greatest value of `f(a)`.

Definition Classes
Foldable1
97. 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
Foldable1Foldable
98. def maximumOf1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): B

The greatest value of `f(a)` for each element `a` of `fa`.

The greatest value of `f(a)` for each element `a` of `fa`.

Definition Classes
Foldable1
99. 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
Foldable1Foldable
100. def minimum1[A](fa: F[A])(implicit arg0: Order[A]): A

The smallest element of `fa`.

The smallest element of `fa`.

Definition Classes
Foldable1
101. 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
Foldable1Foldable
102. def minimumBy1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): A

The element `a` of `fa` which yield the smallest value of `f(a)`.

The element `a` of `fa` which yield the smallest value of `f(a)`.

Definition Classes
Foldable1
103. 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
Foldable1Foldable
104. def minimumOf1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): B

The smallest value of `f(a)` for each element `a` of `fa`.

The smallest value of `f(a)` for each element `a` of `fa`.

Definition Classes
Foldable1
105. def msuml[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]
Definition Classes
Foldable
106. def msuml1[G[_], A](fa: F[G[A]])(implicit G: Plus[G]): G[A]
Definition Classes
Foldable1
107. def msumlU[GA](fa: F[GA])(implicit G: Unapply[PlusEmpty, GA]): M[A]
Definition Classes
FoldableParent
108. final def naturalTrans: ~>[F, G]
Attributes
protected[this]
Definition Classes
IsomorphismTraverseIsomorphismFoldable
109. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
110. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
111. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
112. def product[G[_]](implicit G0: Traverse1[G]): Traverse1[[α](F[α], G[α])]

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

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

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

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

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

Definition Classes
Foldable1
114. 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

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

Definition Classes
Traverse
115. 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
116. 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
117. def product0[G[_]](implicit G0: Traverse[G]): Traverse1[[α](F[α], G[α])]

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

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

Definition Classes
Traverse1
118. def product0[G[_]](implicit G0: Foldable[G]): Foldable1[[α](F[α], G[α])]

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

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

Definition Classes
Foldable1
119. 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

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

Definition Classes
Traverse
120. 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
121. def reverse[A](fa: F[A]): F[A]
Definition Classes
Traverse
122. def runTraverseS[S, A, B](fa: F[A], s: S)(f: (A) ⇒ State[S, B]): (S, F[B])
Definition Classes
Traverse
123. def scanLeft1[A](fa: F[A])(f: (A, A) ⇒ A): NonEmptyList[A]
Definition Classes
Foldable1
124. def scanRight1[A](fa: F[A])(f: (A, A) ⇒ A): NonEmptyList[A]
Definition Classes
Foldable1
125. 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
126. def sequence[G[_], A](fga: F[G[A]])(implicit arg0: Applicative[G]): G[F[A]]

Traverse with the identity function.

Traverse with the identity function.

Definition Classes
Traverse
127. def sequence1[G[_], A](fga: F[G[A]])(implicit arg0: Apply[G]): G[F[A]]
Definition Classes
Traverse1
128. final def sequence1U[GA](fga: F[GA])(implicit G: Unapply[Apply, GA]): M[F[A]]
Definition Classes
Traverse1
129. def sequence1_[M[_], A](fa: F[M[A]])(implicit a: Apply[M], x: Semigroup[M[A]]): M[Unit]
Definition Classes
Foldable1
130. 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
131. 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
132. def sequenceS[S, A](fga: F[State[S, A]]): State[S, F[A]]

Traverse with `State`.

Traverse with `State`.

Definition Classes
Traverse
133. def sequenceS_[S, A](fga: F[State[S, A]]): State[S, Unit]

`sequence_` specialized to `State` *

`sequence_` specialized to `State` *

Definition Classes
Foldable
134. 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.

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

Definition Classes
Traverse
135. 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
136. 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
137. 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
138. 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
139. 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
140. 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
141. def suml[A](fa: F[A])(implicit A: Monoid[A]): A
Definition Classes
Foldable
142. def suml1[A](fa: F[A])(implicit A: Semigroup[A]): A
Definition Classes
Foldable1
143. def suml1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
Definition Classes
Foldable
144. def sumr[A](fa: F[A])(implicit A: Monoid[A]): A
Definition Classes
Foldable
145. def sumr1[A](fa: F[A])(implicit A: Semigroup[A]): A
Definition Classes
Foldable1
146. def sumr1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
Definition Classes
Foldable
147. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
148. def toEphemeralStream[A](fa: F[A]): EphemeralStream[A]
Definition Classes
Foldable
149. def toIList[A](fa: F[A]): IList[A]
Definition Classes
Foldable
150. def toList[A](fa: F[A]): List[A]
Definition Classes
Foldable
151. def toNel[A](fa: F[A]): NonEmptyList[A]
Definition Classes
Foldable1
152. def toSet[A](fa: F[A]): Set[A]
Definition Classes
Foldable
153. def toStream[A](fa: F[A]): Stream[A]
Definition Classes
Foldable
154. def toString()
Definition Classes
AnyRef → Any
155. def toVector[A](fa: F[A]): Vector[A]
Definition Classes
Foldable
156. def traversal[G[_]](implicit arg0: Applicative[G]): Traversal[G]
Definition Classes
Traverse
157. def traversalS[S]: Traversal[[β\$0\$]IndexedStateT[[X]X, S, S, β\$0\$]]
Definition Classes
Traverse
158. def traverse[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit arg0: Applicative[G]): G[F[B]]
Definition Classes
Traverse
159. def traverse1[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit a: Apply[G]): G[F[B]]
Definition Classes
Traverse1
160. def traverse1Impl[H[_], A, B](fa: F[A])(f: (A) ⇒ H[B])(implicit arg0: Apply[H]): H[F[B]]

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

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

Definition Classes
IsomorphismTraverse1Traverse1
161. def traverse1Law
Definition Classes
Traverse1
162. val traverse1Syntax: Traverse1Syntax[F]
Definition Classes
Traverse1
163. final def traverse1U[A, GB](fa: F[A])(f: (A) ⇒ GB)(implicit G: Unapply[Apply, GB]): M[F[A]]
Definition Classes
Traverse1
164. def traverse1_[M[_], A, B](fa: F[A])(f: (A) ⇒ M[B])(implicit a: Apply[M], x: Semigroup[M[B]]): M[Unit]
Definition Classes
Foldable1
165. def traverseImpl[H[_], A, B](fa: F[A])(f: (A) ⇒ H[B])(implicit arg0: Applicative[H]): H[F[B]]

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

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

Definition Classes
IsomorphismTraverseTraverse
166. 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.

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

Definition Classes
Traverse
167. def traverseLaw
Definition Classes
Traverse
168. 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.

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

Definition Classes
Traverse
169. def traverseS[S, A, B](fa: F[A])(f: (A) ⇒ State[S, B]): State[S, F[B]]

Traverse with `State`.

Traverse with `State`.

Definition Classes
Traverse
170. 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.

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

Definition Classes
Traverse
171. 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
172. val traverseSyntax: TraverseSyntax[F]
Definition Classes
Traverse
173. 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`.

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

Definition Classes
Traverse
174. 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
175. 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
176. 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
177. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
178. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
179. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@native() @throws( ... )
180. 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
181. 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
182. 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
183. 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
184. def zipL[A, B](fa: F[A], fb: F[B]): F[(A, Option[B])]
Definition Classes
Traverse
185. def zipR[A, B](fa: F[A], fb: F[B]): F[(Option[A], B)]
Definition Classes
Traverse
186. def zipWith[A, B, C](fa: F[A], fb: F[B])(f: (A, Option[B]) ⇒ C): (List[B], F[C])
Definition Classes
Traverse
187. def zipWithL[A, B, C](fa: F[A], fb: F[B])(f: (A, Option[B]) ⇒ C): F[C]
Definition Classes
Traverse
188. def zipWithR[A, B, C](fa: F[A], fb: F[B])(f: (Option[A], B) ⇒ C): F[C]
Definition Classes
Traverse

### 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