t

scalaz

# Bitraverse 

### Companion object Bitraverse

#### trait Bitraverse[F[_, _]] extends Bifunctor[F] with Bifoldable[F]

A type giving rise to two unrelated scalaz.Traverses.

Self Type
Bitraverse[F]
Source
Bitraverse.scala
Linear Supertypes
Known Subclasses
Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. Bitraverse
2. Bifoldable
3. Bifunctor
4. BifunctorParent
5. AnyRef
6. Any
1. Hide All
2. Show All
Visibility
1. Public
2. All

### Type Members

1. trait BifoldableLaw extends AnyRef
Definition Classes
Bifoldable
2. class Bitraversal [G[_]] extends AnyRef

### Abstract Value Members

1. abstract def bitraverseImpl[G[_], A, B, C, D](fab: F[A, B])(f: (A) ⇒ G[C], g: (B) ⇒ G[D])(implicit arg0: Applicative[G]): G[F[C, D]]

Collect `G`s while applying `f` and `g` in some order.

### 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. final def asInstanceOf[T0]: T0
Definition Classes
Any
5. final def bifoldL[A, B, C](fa: F[A, B], z: C)(f: (C) ⇒ (A) ⇒ C)(g: (C) ⇒ (B) ⇒ C): C

Curried version of `bifoldLeft`

Curried version of `bifoldLeft`

Definition Classes
Bifoldable
6. def bifoldLShape[A, B, C](fa: F[A, B], z: C)(f: (C, A) ⇒ C)(g: (C, B) ⇒ C): (C, F[Unit, Unit])
7. def bifoldLeft[A, B, C](fa: F[A, B], z: C)(f: (C, A) ⇒ C)(g: (C, B) ⇒ C): C

`bifoldRight`, but defined to run in the opposite direction.

`bifoldRight`, but defined to run in the opposite direction.

Definition Classes
BitraverseBifoldable
8. def bifoldMap[A, B, M](fa: F[A, B])(f: (A) ⇒ M)(g: (B) ⇒ M)(implicit F: Monoid[M]): M

Accumulate `A`s and `B`s

Accumulate `A`s and `B`s

Definition Classes
BitraverseBifoldable
9. def bifoldMap1[A, B, M](fa: F[A, B])(f: (A) ⇒ M)(g: (B) ⇒ M)(implicit F: Semigroup[M]): Option[M]
Definition Classes
Bifoldable
10. final def bifoldR[A, B, C](fa: F[A, B], z: ⇒ C)(f: (A) ⇒ (⇒ C) ⇒ C)(g: (B) ⇒ (⇒ C) ⇒ C): C

Curried version of `bifoldRight`

Curried version of `bifoldRight`

Definition Classes
Bifoldable
11. def bifoldRight[A, B, C](fa: F[A, B], z: ⇒ C)(f: (A, ⇒ C) ⇒ C)(g: (B, ⇒ C) ⇒ C): C

Accumulate to `C` starting at the "right".

Accumulate to `C` starting at the "right". `f` and `g` may be interleaved.

Definition Classes
BitraverseBifoldable
12. def bifoldableLaw
Definition Classes
Bifoldable
13. val bifoldableSyntax: BifoldableSyntax[F]
Definition Classes
Bifoldable
14. val bifunctorSyntax: BifunctorSyntax[F]
Definition Classes
Bifunctor
15. def bimap[A, B, C, D](fab: F[A, B])(f: (A) ⇒ C, g: (B) ⇒ D): F[C, D]

`map` over both type parameters.

`map` over both type parameters.

Definition Classes
BitraverseBifunctor
16. def bisequence[G[_], A, B](x: F[G[A], G[B]])(implicit arg0: Applicative[G]): G[F[A, B]]
17. def bitraversal[G[_]](implicit arg0: Applicative[G]): Bitraversal[G]
18. def bitraversalS[S]: Bitraversal[[β\$2\$]IndexedStateT[[X]X, S, S, β\$2\$]]
19. def bitraverse[G[_], A, B, C, D](fa: F[A, B])(f: (A) ⇒ G[C])(g: (B) ⇒ G[D])(implicit arg0: Applicative[G]): G[F[C, D]]
20. def bitraverseF[G[_], A, B, C, D](f: (A) ⇒ G[C], g: (B) ⇒ G[D])(implicit arg0: Applicative[G]): (F[A, B]) ⇒ G[F[C, D]]

Flipped `bitraverse`.

21. def bitraverseKTrampoline[S, G[_], A, B, C, D](fa: F[A, B])(f: (A) ⇒ Kleisli[G, S, C])(g: (B) ⇒ Kleisli[G, S, D])(implicit arg0: Applicative[G]): Kleisli[G, S, F[C, D]]

Bitraverse `fa` with a `Kleisli[G, S, C]` and `Kleisli[G, S, D]`, internally using a `Trampoline` to avoid stack overflow.

22. def bitraverseS[S, A, B, C, D](fa: F[A, B])(f: (A) ⇒ State[S, C])(g: (B) ⇒ State[S, D]): State[S, F[C, D]]
23. val bitraverseSyntax: BitraverseSyntax[F]
24. def clone()
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
25. def compose[G[_, _]](implicit G0: Bitraverse[G]): Bitraverse[[α, β]F[G[α, β], G[α, β]]]

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

26. def compose[G[_, _]](implicit G0: Bifoldable[G]): Bifoldable[[α, β]F[G[α, β], G[α, β]]]

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

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

Definition Classes
Bifoldable
27. def compose[G[_, _]](implicit G0: Bifunctor[G]): Bifunctor[[α, β]F[G[α, β], G[α, β]]]

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

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

Definition Classes
Bifunctor
28. def embed[G[_], H[_]](implicit G0: Traverse[G], H0: Traverse[H]): Bitraverse[[α, β]F[G[α], H[β]]]

Embed a Traverse on each side of this Bitraverse .

29. def embed[G[_], H[_]](implicit G0: Foldable[G], H0: Foldable[H]): Bifoldable[[α, β]F[G[α], H[β]]]

Embed one Foldable at each side of this Bifoldable

Embed one Foldable at each side of this Bifoldable

Definition Classes
Bifoldable
30. def embed[G[_], H[_]](implicit G0: Functor[G], H0: Functor[H]): Bifunctor[[α, β]F[G[α], H[β]]]

Embed two Functors , one on each side

Embed two Functors , one on each side

Definition Classes
Bifunctor
31. def embedLeft[G[_]](implicit G0: Traverse[G]): Bitraverse[[α, β]F[G[α], β]]

Embed a Traverse on the left side of this Bitraverse .

32. def embedLeft[G[_]](implicit G0: Foldable[G]): Bifoldable[[α, β]F[G[α], β]]

Embed one Foldable to the left of this Bifoldable .

Embed one Foldable to the left of this Bifoldable .

Definition Classes
Bifoldable
33. def embedLeft[G[_]](implicit G0: Functor[G]): Bifunctor[[α, β]F[G[α], β]]

Embed one Functor to the left

Embed one Functor to the left

Definition Classes
Bifunctor
34. def embedRight[H[_]](implicit H0: Traverse[H]): Bitraverse[[α, β]F[α, H[β]]]

Embed a Traverse on the right side of this Bitraverse .

35. def embedRight[H[_]](implicit H0: Foldable[H]): Bifoldable[[α, β]F[α, H[β]]]

Embed one Foldable to the right of this Bifoldable .

Embed one Foldable to the right of this Bifoldable .

Definition Classes
Bifoldable
36. def embedRight[H[_]](implicit H0: Functor[H]): Bifunctor[[α, β]F[α, H[β]]]

Embed one Functor to the right

Embed one Functor to the right

Definition Classes
Bifunctor
37. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
38. def equals(arg0: Any)
Definition Classes
AnyRef → Any
39. def finalize(): Unit
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
40. final def getClass(): Class[_]
Definition Classes
AnyRef → Any
41. def hashCode(): Int
Definition Classes
AnyRef → Any
42. final def isInstanceOf[T0]
Definition Classes
Any
43. def leftFoldable[X]: Foldable[[α\$0\$]F[α\$0\$, X]]

Extract the Foldable on the first parameter.

Extract the Foldable on the first parameter.

Definition Classes
Bifoldable
44. def leftFunctor[X]: Functor[[α\$0\$]F[α\$0\$, X]]

Extract the Functor on the first param.

Extract the Functor on the first param.

Definition Classes
Bifunctor
45. def leftMap[A, B, C](fab: F[A, B])(f: (A) ⇒ C): F[C, B]
Definition Classes
Bifunctor
46. def leftTraverse[X]: Traverse[[α\$0\$]F[α\$0\$, X]]

Extract the Traverse on the first param.

47. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
48. final def notify(): Unit
Definition Classes
AnyRef
49. final def notifyAll(): Unit
Definition Classes
AnyRef
50. def product[G[_, _]](implicit G0: Bitraverse[G]): Bitraverse[[α, β](F[α, β], G[α, β])]

The product of Bitraverses `F` and `G`, `[x,y](F[x,y], G[x,y])`, is a Bitraverse

51. def product[G[_, _]](implicit G0: Bifoldable[G]): Bifoldable[[α, β](F[α, β], G[α, β])]

The product of Bifoldables `F` and `G`, `[x,y](F[x,y], G[x,y])`, is a Bifoldable

The product of Bifoldables `F` and `G`, `[x,y](F[x,y], G[x,y])`, is a Bifoldable

Definition Classes
Bifoldable
52. def product[G[_, _]](implicit G0: Bifunctor[G]): Bifunctor[[α, β](F[α, β], G[α, β])]

The product of Bifunctors `F` and `G`, `[x,y](F[x,y], G[x,y])`, is a Bifunctor

The product of Bifunctors `F` and `G`, `[x,y](F[x,y], G[x,y])`, is a Bifunctor

Definition Classes
Bifunctor
53. def rightFoldable[X]: Foldable[[β\$1\$]F[X, β\$1\$]]

Extract the Foldable on the second parameter.

Extract the Foldable on the second parameter.

Definition Classes
Bifoldable
54. def rightFunctor[X]: Functor[[β\$1\$]F[X, β\$1\$]]

Extract the Functor on the second param.

Extract the Functor on the second param.

Definition Classes
Bifunctor
55. def rightMap[A, B, D](fab: F[A, B])(g: (B) ⇒ D): F[A, D]
Definition Classes
Bifunctor
56. def rightTraverse[X]: Traverse[[β\$1\$]F[X, β\$1\$]]

Extract the Traverse on the second param.

57. def runBitraverseS[S, A, B, C, D](fa: F[A, B], s: S)(f: (A) ⇒ State[S, C])(g: (B) ⇒ State[S, D]): (S, F[C, D])
58. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
59. def toString()
Definition Classes
AnyRef → Any
60. def traverseSTrampoline[S, G[_], A, B, C, D](fa: F[A, B])(f: (A) ⇒ State[S, G[C]])(g: (B) ⇒ State[S, G[D]])(implicit arg0: Applicative[G]): State[S, G[F[C, D]]]

Bitraverse `fa` with a `State[S, G[C]]` and `State[S, G[D]]`, internally using a `Trampoline` to avoid stack overflow.

61. def uFoldable: Foldable[[α]F[α, α]]

Unify the foldable over both params.

Unify the foldable over both params.

Definition Classes
Bifoldable
62. def uFunctor: Functor[[α]F[α, α]]

Unify the functor over both params.

Unify the functor over both params.

Definition Classes
Bifunctor
63. def uTraverse: Traverse[[α]F[α, α]]

Unify the traverse over both params.

64. def umap[A, B](faa: F[A, A])(f: (A) ⇒ B): F[B, B]
Definition Classes
Bifunctor
65. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
66. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
67. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
68. def widen[A, B, C >: A, D >: B](fab: F[A, B]): F[C, D]

Bifunctors are covariant by nature

Bifunctors are covariant by nature

Definition Classes
BifunctorParent