scalaz

# IsomorphismBitraverse

#### trait IsomorphismBitraverse[F[_, _], G[_, _]] extends Bitraverse[F] with IsomorphismBifunctor[F, G]

Source
Isomorphism.scala
Linear Supertypes
IsomorphismBifunctor[F, G], Bitraverse[F], Bifoldable[F], Bifunctor[F], AnyRef, Any
Ordering
1. Alphabetic
2. By inheritance
Inherited
1. IsomorphismBitraverse
2. IsomorphismBifunctor
3. Bitraverse
4. Bifoldable
5. Bifunctor
6. AnyRef
7. Any
1. Hide All
2. Show all
Visibility
1. Public
2. All

### Type Members

1. #### class Bitraversal[G[_]] extends AnyRef

Definition Classes
Bitraverse

### Abstract Value Members

2. #### abstract def iso: Isomorphism.<~~>[F, G]

Definition Classes
IsomorphismBifunctor

### 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
8. #### def bifoldLShape[A, B, C](fa: F[A, B], z: C)(f: (C, A) ⇒ C)(g: (C, B) ⇒ C): (C, F[Unit, Unit])

Definition Classes
Bitraverse
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
IsomorphismBifunctorBifunctor
17. #### def bisequence[G[_], A, B](x: F[G[A], G[B]])(implicit arg0: Applicative[G]): G[F[A, B]]

Definition Classes
Bitraverse
18. #### def bitraversal[G[_]](implicit arg0: Applicative[G]): Bitraversal[G]

Definition Classes
Bitraverse
19. #### def bitraversalS[S]: Bitraversal[[x]IndexedStateT[[+X]X, S, S, x]]

Definition Classes
Bitraverse
20. #### 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]]

Definition Classes
Bitraverse
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`.

Flipped `bitraverse`.

Definition Classes
Bitraverse
22. #### def bitraverseImpl[H[_], A, B, C, D](fab: F[A, B])(f: (A) ⇒ H[C], g: (B) ⇒ H[D])(implicit arg0: Applicative[H]): H[F[C, D]]

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

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

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

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

Definition Classes
Bitraverse
24. #### 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]]

Definition Classes
Bitraverse
25. #### val bitraverseSyntax: BitraverseSyntax[F]

Definition Classes
Bitraverse
26. #### def clone(): AnyRef

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

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

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

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

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

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

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

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

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

Extract the Foldable on the first parameter.

Extract the Foldable on the first parameter.

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

Extract the Functor on the first param.

Extract the Functor on the first param.

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

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

Extract the Traverse on the first param.

Extract the Traverse on the first param.

Definition Classes
Bitraverse
40. #### final def ne(arg0: AnyRef): Boolean

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

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

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

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

Definition Classes
Bitraverse
44. #### 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
45. #### 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
46. #### def rightFoldable[X]: Foldable[[α]F[X, α]]

Extract the Foldable on the second parameter.

Extract the Foldable on the second parameter.

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

Extract the Functor on the second param.

Extract the Functor on the second param.

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

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

Extract the Traverse on the second param.

Extract the Traverse on the second param.

Definition Classes
Bitraverse
50. #### 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])

Definition Classes
Bitraverse
51. #### final def synchronized[T0](arg0: ⇒ T0): T0

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

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

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

Definition Classes
Bitraverse
54. #### def umap[A, B](faa: F[A, A])(f: (A) ⇒ B): F[B, B]

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

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )