 scalaz

# 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
Bifoldable[F], Bifunctor[F], AnyRef, Any
Known Subclasses
Ordering
1. Alphabetic
2. By inheritance
Inherited
1. Bitraverse
2. Bifoldable
3. Bifunctor
4. AnyRef
5. Any
1. Hide All
2. Show all
Learn more about member selection
Visibility
1. Public
2. All

### 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: AnyRef): Boolean

Definition Classes
AnyRef
2. #### final def !=(arg0: Any): Boolean

Definition Classes
Any
3. #### final def ##(): Int

Definition Classes
AnyRef → Any
4. #### final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
5. #### final def ==(arg0: Any): Boolean

Definition Classes
Any
6. #### final def asInstanceOf[T0]: T0

Definition Classes
Any
7. #### 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

9. #### 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
10. #### 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 in some unspecified order.

Accumulate `A`s and `B`s in some unspecified order.

Definition Classes
BitraverseBifoldable
11. #### def bifoldMap1[A, B, M](fa: F[A, B])(f: (A) ⇒ M)(g: (B) ⇒ M)(implicit F: Semigroup[M]): Option[M]

Definition Classes
Bifoldable
12. #### 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
13. #### 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
14. #### val bifoldableSyntax: BifoldableSyntax[F]

Definition Classes
Bifoldable
15. #### val bifunctorSyntax: BifunctorSyntax[F]

Definition Classes
Bifunctor
16. #### 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

21. #### 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`.

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

25. #### def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
26. #### 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

27. #### 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
28. #### 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
29. #### final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
30. #### def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
31. #### def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
32. #### final def getClass(): Class[_]

Definition Classes
AnyRef → Any
33. #### def hashCode(): Int

Definition Classes
AnyRef → Any
34. #### final def isInstanceOf[T0]: Boolean

Definition Classes
Any
35. #### def leftFoldable[X]: Foldable[[α]F[α, X]]

Extract the Foldable on the first parameter.

Extract the Foldable on the first parameter.

Definition Classes
Bifoldable
36. #### def leftFunctor[X]: Functor[[α]F[α, X]]

Extract the Functor on the first param.

Extract the Functor on the first param.

Definition Classes
Bifunctor
37. #### def leftMap[A, B, C](fab: F[A, B])(f: (A) ⇒ C): F[C, B]

Definition Classes
Bifunctor
38. #### def leftTraverse[X]: Traverse[[α]F[α, X]]

Extract the Traverse on the first param.

39. #### final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
40. #### final def notify(): Unit

Definition Classes
AnyRef
41. #### final def notifyAll(): Unit

Definition Classes
AnyRef
42. #### def product[G[_, _]](implicit G0: Bitraverse[G]): Bitraverse[[α, β](F[α, β], G[α, β])]

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

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

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

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

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

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

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

Definition Classes
Bifunctor
45. #### def rightFoldable[X]: Foldable[[α]F[X, α]]

Extract the Foldable on the second parameter.

Extract the Foldable on the second parameter.

Definition Classes
Bifoldable
46. #### def rightFunctor[X]: Functor[[α]F[X, α]]

Extract the Functor on the second param.

Extract the Functor on the second param.

Definition Classes
Bifunctor
47. #### def rightMap[A, B, D](fab: F[A, B])(g: (B) ⇒ D): F[A, D]

Definition Classes
Bifunctor
48. #### def rightTraverse[X]: Traverse[[α]F[X, α]]

Extract the Traverse on the second param.

50. #### final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
51. #### def toString(): String

Definition Classes
AnyRef → Any
52. #### 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.

53. #### def umap[A, B](faa: F[A, A])(f: (A) ⇒ B): F[B, B]

Definition Classes
Bifunctor
54. #### final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
55. #### final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
56. #### final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )