t

scalaz

# IsomorphismApplicativePlus 

#### trait IsomorphismApplicativePlus[F[_], G[_]] extends ApplicativePlus[F] with IsomorphismEmpty[F, G] with IsomorphismApplicative[F, G]

Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. IsomorphismApplicativePlus
2. IsomorphismApplicative
3. IsomorphismApply
4. IsomorphismFunctor
5. IsomorphismEmpty
6. IsomorphismPlus
7. ApplicativePlus
8. PlusEmpty
9. Plus
10. Applicative
11. ApplicativeParent
12. Apply
13. ApplyParent
14. Functor
15. InvariantFunctor
16. AnyRef
17. Any
1. Hide All
2. Show All
Visibility
1. Public
2. All

### Type Members

1. trait ApplicativeLaw extends ApplyLaw
Definition Classes
Applicative
2. trait ApplyLaw extends FunctorLaw
Definition Classes
Apply
3. trait FunctorLaw extends InvariantFunctorLaw
Definition Classes
Functor
4. trait InvariantFunctorLaw extends AnyRef
Definition Classes
InvariantFunctor
5. trait PlusLaw extends AnyRef
Definition Classes
Plus
6. trait EmptyLaw extends PlusLaw
Definition Classes
PlusEmpty

### Abstract Value Members

1. implicit abstract def G: ApplicativePlus[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 ap[A, B](fa: ⇒ F[A])(f: ⇒ F[(A) ⇒ B]): F[B]

Sequence `f`, then `fa`, combining their results by function application.

Sequence `f`, then `fa`, combining their results by function application.

NB: with respect to `apply2` and all other combinators, as well as scalaz.Bind, the `f` action appears to the *left*. So `f` should be the "first" `F`-action to perform. This is in accordance with all other implementations of this typeclass in common use, which are "function first".

Definition Classes
IsomorphismApplicativeIsomorphismApplyApply
5. def ap2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: F[(A, B) ⇒ C]): F[C]
Definition Classes
Apply
6. def ap3[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: F[(A, B, C) ⇒ D]): F[D]
Definition Classes
Apply
7. def ap4[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D])(f: F[(A, B, C, D) ⇒ E]): F[E]
Definition Classes
Apply
8. def ap5[A, B, C, D, E, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E])(f: F[(A, B, C, D, E) ⇒ R]): F[R]
Definition Classes
Apply
9. def ap6[A, B, C, D, E, FF, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF])(f: F[(A, B, C, D, E, FF) ⇒ R]): F[R]
Definition Classes
Apply
10. def ap7[A, B, C, D, E, FF, G, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G])(f: F[(A, B, C, D, E, FF, G) ⇒ R]): F[R]
Definition Classes
Apply
11. def ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H])(f: F[(A, B, C, D, E, FF, G, H) ⇒ R]): F[R]
Definition Classes
Apply
12. def apF[A, B](f: ⇒ F[(A) ⇒ B]): (F[A]) ⇒ F[B]

Flipped variant of `ap`.

Flipped variant of `ap`.

Definition Classes
Apply
13. def applicativeLaw
Definition Classes
Applicative
14. val applicativePlusSyntax
Definition Classes
ApplicativePlus
15. val applicativeSyntax
Definition Classes
Applicative
16. def apply[A, B](fa: F[A])(f: (A) ⇒ B): F[B]

Alias for `map`.

Alias for `map`.

Definition Classes
Functor
17. def apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J])(f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): F[R]
Definition Classes
Apply
18. def apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J], fk: ⇒ F[K])(f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): F[R]
Definition Classes
Apply
19. def apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I], fj: ⇒ F[J], fk: ⇒ F[K], fl: ⇒ F[L])(f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): F[R]
Definition Classes
Apply
20. def apply2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: (A, B) ⇒ C): F[C]
Definition Classes
IsomorphismApplicativeApplicativeApply
21. def apply3[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: (A, B, C) ⇒ D): F[D]
Definition Classes
Apply
22. def apply4[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D])(f: (A, B, C, D) ⇒ E): F[E]
Definition Classes
Apply
23. def apply5[A, B, C, D, E, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E])(f: (A, B, C, D, E) ⇒ R): F[R]
Definition Classes
Apply
24. def apply6[A, B, C, D, E, FF, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF])(f: (A, B, C, D, E, FF) ⇒ R): F[R]
Definition Classes
Apply
25. def apply7[A, B, C, D, E, FF, G, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G])(f: (A, B, C, D, E, FF, G) ⇒ R): F[R]
Definition Classes
Apply
26. def apply8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H])(f: (A, B, C, D, E, FF, G, H) ⇒ R): F[R]
Definition Classes
Apply
27. def apply9[A, B, C, D, E, FF, G, H, I, R](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], ff: ⇒ F[FF], fg: ⇒ F[G], fh: ⇒ F[H], fi: ⇒ F[I])(f: (A, B, C, D, E, FF, G, H, I) ⇒ R): F[R]
Definition Classes
Apply
28. def applyApplicative: Applicative[[α]\/[F[α], α]]

Add a unit to any Apply to form an Applicative.

Add a unit to any Apply to form an Applicative.

Definition Classes
Apply
29. def applyLaw
Definition Classes
Apply
30. val applySyntax: ApplySyntax[F]
Definition Classes
Apply
31. final def asInstanceOf[T0]: T0
Definition Classes
Any
32. 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
33. def clone()
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
34. def compose[G[_]](implicit G0: Applicative[G]): ApplicativePlus[[α]F[G[α]]]

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

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

Definition Classes
ApplicativePlusApplicative
35. def compose[G[_]]: PlusEmpty[[α]F[G[α]]]

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

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

Definition Classes
PlusEmptyPlus
36. def compose[G[_]](implicit G0: Apply[G]): Apply[[α]F[G[α]]]

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

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

Definition Classes
Apply
37. 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
38. def counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]
Definition Classes
Functor
39. def discardLeft[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[B]

Combine `fa` and `fb` according to `Apply[F]` with a function that discards the `A`(s)

Combine `fa` and `fb` according to `Apply[F]` with a function that discards the `A`(s)

Definition Classes
ApplyParent
40. def discardRight[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[A]

Combine `fa` and `fb` according to `Apply[F]` with a function that discards the `B`(s)

Combine `fa` and `fb` according to `Apply[F]` with a function that discards the `B`(s)

Definition Classes
ApplyParent
41. def empty[A]: F[A]
Definition Classes
IsomorphismEmptyPlusEmpty
42. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
43. def equals(arg0: Any)
Definition Classes
AnyRef → Any
44. def filterM[A](l: List[A])(f: (A) ⇒ F[Boolean]): F[List[A]]

Filter `l` according to an applicative predicate.

Filter `l` according to an applicative predicate.

Definition Classes
Applicative
45. def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
46. def flip: Applicative[F]

An `Applicative` for `F` in which effects happen in the opposite order.

An `Applicative` for `F` in which effects happen in the opposite order.

Definition Classes
ApplicativeApplyParent
47. def forever[A, B](fa: F[A]): F[B]

Repeats an applicative action infinitely

Repeats an applicative action infinitely

Definition Classes
ApplyParent
48. def fpair[A](fa: F[A]): F[(A, A)]

Twin all `A`s in `fa`.

Twin all `A`s in `fa`.

Definition Classes
Functor
49. 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
50. def functorLaw
Definition Classes
Functor
51. val functorSyntax: FunctorSyntax[F]
Definition Classes
Functor
52. final def getClass(): Class[_]
Definition Classes
AnyRef → Any
Annotations
@native()
53. def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
54. 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
55. def invariantFunctorLaw
Definition Classes
InvariantFunctor
56. val invariantFunctorSyntax
Definition Classes
InvariantFunctor
57. final def isInstanceOf[T0]
Definition Classes
Any
58. def lift[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[B]

Lift `f` into `F`.

Lift `f` into `F`.

Definition Classes
Functor
59. def lift10[A, B, C, D, E, FF, G, H, I, J, R](f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J]) ⇒ F[R]
Definition Classes
Apply
60. def lift11[A, B, C, D, E, FF, G, H, I, J, K, R](f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J], F[K]) ⇒ F[R]
Definition Classes
Apply
61. def lift12[A, B, C, D, E, FF, G, H, I, J, K, L, R](f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I], F[J], F[K], F[L]) ⇒ F[R]
Definition Classes
Apply
62. def lift2[A, B, C](f: (A, B) ⇒ C): (F[A], F[B]) ⇒ F[C]
Definition Classes
Apply
63. def lift3[A, B, C, D](f: (A, B, C) ⇒ D): (F[A], F[B], F[C]) ⇒ F[D]
Definition Classes
Apply
64. def lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (F[A], F[B], F[C], F[D]) ⇒ F[E]
Definition Classes
Apply
65. def lift5[A, B, C, D, E, R](f: (A, B, C, D, E) ⇒ R): (F[A], F[B], F[C], F[D], F[E]) ⇒ F[R]
Definition Classes
Apply
66. def lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF]) ⇒ F[R]
Definition Classes
Apply
67. def lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G]) ⇒ F[R]
Definition Classes
Apply
68. def lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H]) ⇒ F[R]
Definition Classes
Apply
69. def lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) ⇒ R): (F[A], F[B], F[C], F[D], F[E], F[FF], F[G], F[H], F[I]) ⇒ F[R]
Definition Classes
Apply
70. def many[A](a: F[A]): F[List[A]]

A list of results acquired by repeating `a`.

A list of results acquired by repeating `a`. Never `empty`; initial failure is an empty list instead.

Definition Classes
ApplicativePlus
71. 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
72. 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
73. def monoid[A]: Monoid[F[A]]
Definition Classes
PlusEmpty
74. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
75. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
76. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
77. def par: Par[F]

A lawful implementation of this that is isomorphic up to the methods defined on Applicative allowing for optimised parallel implementations that would otherwise violate laws of more specific typeclasses (e.g.

A lawful implementation of this that is isomorphic up to the methods defined on Applicative allowing for optimised parallel implementations that would otherwise violate laws of more specific typeclasses (e.g. Monad).

Definition Classes
ApplicativeParent
78. def plus[A](a: F[A], b: ⇒ F[A]): F[A]
Definition Classes
IsomorphismPlusPlus
79. def plusEmptyLaw
Definition Classes
PlusEmpty
80. val plusEmptySyntax: PlusEmptySyntax[F]
Definition Classes
PlusEmpty
81. def plusLaw
Definition Classes
Plus
82. val plusSyntax: PlusSyntax[F]
Definition Classes
Plus
83. def point[A](a: ⇒ A): F[A]
Definition Classes
IsomorphismApplicativeApplicative
84. def product[G[_]](implicit G0: ApplicativePlus[G]): ApplicativePlus[[α](F[α], G[α])]

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

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

Definition Classes
ApplicativePlus
85. def product[G[_]](implicit G0: PlusEmpty[G]): PlusEmpty[[α](F[α], G[α])]

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

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

Definition Classes
PlusEmpty
86. def product[G[_]](implicit G0: Plus[G]): Plus[[α](F[α], G[α])]

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

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

Definition Classes
Plus
87. def product[G[_]](implicit G0: Applicative[G]): Applicative[[α](F[α], G[α])]

The product of Applicatives `F` and `G`, `[x](F[x], G[x]])`, is an Applicative

The product of Applicatives `F` and `G`, `[x](F[x], G[x]])`, is an Applicative

Definition Classes
Applicative
88. def product[G[_]](implicit G0: Apply[G]): Apply[[α](F[α], G[α])]

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

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

Definition Classes
Apply
89. 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
90. final def pure[A](a: ⇒ A): F[A]
Definition Classes
Applicative
91. def replicateM[A](n: Int, fa: F[A]): F[List[A]]

Performs the action `n` times, returning the list of results.

Performs the action `n` times, returning the list of results.

Definition Classes
Applicative
92. def replicateM_[A](n: Int, fa: F[A]): F[Unit]

Performs the action `n` times, returning nothing.

Performs the action `n` times, returning nothing.

Definition Classes
Applicative
93. def semigroup[A]: Semigroup[F[A]]
Definition Classes
Plus
94. def sequence[A, G[_]](as: G[F[A]])(implicit arg0: Traverse[G]): F[G[A]]
Definition Classes
Applicative
95. def sequence1[A, G[_]](as: G[F[A]])(implicit arg0: Traverse1[G]): F[G[A]]
Definition Classes
Apply
96. def some[A](a: F[A]): F[List[A]]

`empty` or a non-empty list of results acquired by repeating `a`.

`empty` or a non-empty list of results acquired by repeating `a`.

Definition Classes
ApplicativePlus
97. 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
98. 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
99. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
100. def toString()
Definition Classes
AnyRef → Any
101. def traverse[A, G[_], B](value: G[A])(f: (A) ⇒ F[B])(implicit G: Traverse[G]): F[G[B]]
Definition Classes
Applicative
102. def traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ F[B])(implicit G: Traverse1[G]): F[G[B]]
Definition Classes
Apply
103. def tuple2[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[(A, B)]
Definition Classes
Apply
104. def tuple3[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C]): F[(A, B, C)]
Definition Classes
Apply
105. def tuple4[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D]): F[(A, B, C, D)]
Definition Classes
Apply
106. def tuple5[A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E]): F[(A, B, C, D, E)]
Definition Classes
Apply
107. def unlessM[A](cond: Boolean)(f: ⇒ F[A]): F[Unit]

Returns the given argument if `cond` is `false`, otherwise, unit lifted into F.

Returns the given argument if `cond` is `false`, otherwise, unit lifted into F.

Definition Classes
Applicative
108. 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
109. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
110. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
111. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
112. def whenM[A](cond: Boolean)(f: ⇒ F[A]): F[Unit]

Returns the given argument if `cond` is `true`, otherwise, unit lifted into F.

Returns the given argument if `cond` is `true`, otherwise, unit lifted into F.

Definition Classes
Applicative
113. 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
114. 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
115. 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
116. 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