trait IsomorphismApplicativeError[F[_], G[_], S] extends ApplicativeError[F, S] with IsomorphismApplicative[F, G]
- Alphabetic
- By Inheritance
- IsomorphismApplicativeError
- IsomorphismApplicative
- IsomorphismInvariantApplicative
- IsomorphismApply
- IsomorphismFunctor
- IsomorphismInvariantFunctor
- ApplicativeError
- Applicative
- InvariantApplicative
- Apply
- Functor
- InvariantFunctor
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- trait ApplicativeLaw extends ApplyLaw
- Definition Classes
- Applicative
- trait ApplicativeErrorLaws extends AnyRef
- Definition Classes
- ApplicativeError
- trait ApplyLaw extends FunctorLaw
- Definition Classes
- Apply
- trait FlippedApply extends Apply[F]
- Attributes
- protected[this]
- Definition Classes
- Apply
- trait FunctorLaw extends InvariantFunctorLaw
- Definition Classes
- Functor
- trait InvariantFunctorLaw extends AnyRef
- Definition Classes
- InvariantFunctor
Abstract Value Members
- implicit abstract def G: ApplicativeError[G, S]
- abstract def iso: Isomorphism.<~>[F, G]
- Definition Classes
- IsomorphismFunctor → IsomorphismInvariantFunctor
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def ap[A, B](fa: => F[A])(f: => F[(A) => B]): F[B]
Sequence
f, thenfa, combining their results by function application.Sequence
f, thenfa, combining their results by function application.NB: with respect to
apply2and all other combinators, as well as scalaz.Bind, thefaction appears to the *left*. Sofshould 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
- IsomorphismApplicative → IsomorphismApply → Apply
- def ap2[A, B, C](fa: => F[A], fb: => F[B])(f: F[(A, B) => C]): F[C]
- Definition Classes
- Apply
- 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
- 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
- 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
- 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
- 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
- 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
- def apF[A, B](f: => F[(A) => B]): (F[A]) => F[B]
Flipped variant of
ap.Flipped variant of
ap.- Definition Classes
- Apply
- def applicativeErrorLaws: ApplicativeErrorLaws
- Definition Classes
- ApplicativeError
- val applicativeErrorSyntax: ApplicativeErrorSyntax[F, S]
- Definition Classes
- ApplicativeError
- def applicativeLaw: ApplicativeLaw
- Definition Classes
- Applicative
- val applicativeSyntax: ApplicativeSyntax[F]
- Definition Classes
- Applicative
- def apply[A, B](fa: F[A])(f: (A) => B): F[B]
Alias for
map.Alias for
map.- Definition Classes
- Functor
- 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
- 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
- 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
- def apply2[A, B, C](fa: => F[A], fb: => F[B])(f: (A, B) => C): F[C]
- Definition Classes
- IsomorphismApplicative → IsomorphismApply → Applicative → Apply
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- def applyLaw: ApplyLaw
- Definition Classes
- Apply
- val applySyntax: ApplySyntax[F]
- Definition Classes
- Apply
- final def applying1[Z, A1](f: (A1) => Z)(implicit a1: F[A1]): F[Z]
- Definition Classes
- Apply
- final def applying2[Z, A1, A2](f: (A1, A2) => Z)(implicit a1: F[A1], a2: F[A2]): F[Z]
- Definition Classes
- Apply
- final def applying3[Z, A1, A2, A3](f: (A1, A2, A3) => Z)(implicit a1: F[A1], a2: F[A2], a3: F[A3]): F[Z]
- Definition Classes
- Apply
- final def applying4[Z, A1, A2, A3, A4](f: (A1, A2, A3, A4) => Z)(implicit a1: F[A1], a2: F[A2], a3: F[A3], a4: F[A4]): F[Z]
- Definition Classes
- Apply
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]F[G[α, β]]]
The composition of Functor
Fand BifunctorG,[x, y]F[G[x, y]], is a BifunctorThe composition of Functor
Fand BifunctorG,[x, y]F[G[x, y]], is a Bifunctor- Definition Classes
- Functor
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]F[G[α]]]
The composition of Applicatives
FandG,[x]F[G[x]], is an ApplicativeThe composition of Applicatives
FandG,[x]F[G[x]], is an Applicative- Definition Classes
- Applicative
- def compose[G[_]](implicit G0: Apply[G]): Apply[[α]F[G[α]]]
The composition of Applys
FandG,[x]F[G[x]], is a ApplyThe composition of Applys
FandG,[x]F[G[x]], is a Apply- Definition Classes
- Apply
- def compose[G[_]](implicit G0: Functor[G]): Functor[[α]F[G[α]]]
The composition of Functors
FandG,[x]F[G[x]], is a FunctorThe composition of Functors
FandG,[x]F[G[x]], is a Functor- Definition Classes
- Functor
- def counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]
- Definition Classes
- Functor
- def discardLeft[A, B](fa: => F[A], fb: => F[B]): F[B]
Combine
faandfbaccording toApply[F]with a function that discards theA(s)Combine
faandfbaccording toApply[F]with a function that discards theA(s)- Definition Classes
- Apply
- def discardRight[A, B](fa: => F[A], fb: => F[B]): F[A]
Combine
faandfbaccording toApply[F]with a function that discards theB(s)Combine
faandfbaccording toApply[F]with a function that discards theB(s)- Definition Classes
- Apply
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def filterM[A](l: IList[A])(f: (A) => F[Boolean]): F[IList[A]]
Filter
laccording to an applicative predicate.Filter
laccording to an applicative predicate.- Definition Classes
- Applicative
- def filterM[A](l: List[A])(f: (A) => F[Boolean]): F[List[A]]
Filter
laccording to an applicative predicate.Filter
laccording to an applicative predicate.- Definition Classes
- Applicative
- def filterM[A, B](map: ==>>[A, B])(f: (B) => F[Boolean])(implicit O: Order[A]): F[==>>[A, B]]
Filter
mapaccording to an applicative predicate.Filter
mapaccording to an applicative predicate. *- Definition Classes
- Applicative
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flip: Applicative[F]
An
ApplicativeforFin which effects happen in the opposite order.An
ApplicativeforFin which effects happen in the opposite order.- Definition Classes
- Applicative → Apply
- def forever[A, B](fa: F[A]): F[B]
Repeats an applicative action infinitely
Repeats an applicative action infinitely
- Definition Classes
- Apply
- def fpair[A](fa: F[A]): F[(A, A)]
Twin all
As infa.Twin all
As infa.- Definition Classes
- Functor
- def fproduct[A, B](fa: F[A])(f: (A) => B): F[(A, B)]
Pair all
As infawith the result of function application.Pair all
As infawith the result of function application.- Definition Classes
- Functor
- def functorLaw: FunctorLaw
- Definition Classes
- Functor
- val functorSyntax: FunctorSyntax[F]
- Definition Classes
- Functor
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def handleError[A](fa: F[A])(f: (S) => F[A]): F[A]
- Definition Classes
- IsomorphismApplicativeError → ApplicativeError
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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
- val invariantApplicativeSyntax: InvariantApplicativeSyntax[F]
- Definition Classes
- InvariantApplicative
- def invariantFunctorLaw: InvariantFunctorLaw
- Definition Classes
- InvariantFunctor
- val invariantFunctorSyntax: InvariantFunctorSyntax[F]
- Definition Classes
- InvariantFunctor
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def lift[A, B](f: (A) => B): (F[A]) => F[B]
Lift
fintoF.Lift
fintoF.- Definition Classes
- Functor
- 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
- 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
- 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
- def lift2[A, B, C](f: (A, B) => C): (F[A], F[B]) => F[C]
- Definition Classes
- Apply
- def lift3[A, B, C, D](f: (A, B, C) => D): (F[A], F[B], F[C]) => F[D]
- Definition Classes
- Apply
- 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
- 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
- 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
- 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
- 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
- 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
- def liftReducer[A, B](implicit r: Reducer[A, B]): Reducer[F[A], F[B]]
- Definition Classes
- Apply
- def map[A, B](fa: F[A])(f: (A) => B): F[B]
Lift
fintoFand apply toF[A].Lift
fintoFand apply toF[A].- Definition Classes
- IsomorphismFunctor → Functor
- def mapply[A, B](a: A)(f: F[(A) => B]): F[B]
Lift
apply(a), and apply the result tof.Lift
apply(a), and apply the result tof.- Definition Classes
- Functor
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- 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
- Applicative
- def plusA[A](x: => F[A], y: => F[A])(implicit sa: Semigroup[A]): F[A]
Semigroups can be added within an Applicative
Semigroups can be added within an Applicative
- Definition Classes
- Applicative
- def point[A](a: => A): F[A]
- Definition Classes
- IsomorphismApplicative → Applicative
- def product[G[_]](implicit G0: Applicative[G]): Applicative[[α](F[α], G[α])]
The product of Applicatives
FandG,[x](F[x], G[x]]), is an ApplicativeThe product of Applicatives
FandG,[x](F[x], G[x]]), is an Applicative- Definition Classes
- Applicative
- def product[G[_]](implicit G0: Apply[G]): Apply[[α](F[α], G[α])]
The product of Applys
FandG,[x](F[x], G[x]]), is a ApplyThe product of Applys
FandG,[x](F[x], G[x]]), is a Apply- Definition Classes
- Apply
- def product[G[_]](implicit G0: Functor[G]): Functor[[α](F[α], G[α])]
The product of Functors
FandG,[x](F[x], G[x]]), is a FunctorThe product of Functors
FandG,[x](F[x], G[x]]), is a Functor- Definition Classes
- Functor
- final def pure[A](a: => A): F[A]
- Definition Classes
- Applicative
- def raiseError[A](e: S): F[A]
- Definition Classes
- IsomorphismApplicativeError → ApplicativeError
- def replicateM[A](n: Int, fa: F[A]): F[IList[A]]
Performs the action
ntimes, returning the list of results.Performs the action
ntimes, returning the list of results.- Definition Classes
- Applicative
- def replicateM_[A](n: Int, fa: F[A]): F[Unit]
Performs the action
ntimes, returning nothing.Performs the action
ntimes, returning nothing.- Definition Classes
- Applicative
- def sequence[A, G[_]](as: G[F[A]])(implicit arg0: Traverse[G]): F[G[A]]
- Definition Classes
- Applicative
- def sequence1[A, G[_]](as: G[F[A]])(implicit arg0: Traverse1[G]): F[G[A]]
- Definition Classes
- Apply
- def strengthL[A, B](a: A, f: F[B]): F[(A, B)]
Inject
ato the left ofBs inf.Inject
ato the left ofBs inf.- Definition Classes
- Functor
- def strengthR[A, B](f: F[A], b: B): F[(A, B)]
Inject
bto the right ofAs inf.Inject
bto the right ofAs inf.- Definition Classes
- Functor
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def traverse[A, G[_], B](value: G[A])(f: (A) => F[B])(implicit G: Traverse[G]): F[G[B]]
- Definition Classes
- Applicative
- def traverse1[A, G[_], B](value: G[A])(f: (A) => F[B])(implicit G: Traverse1[G]): F[G[B]]
- Definition Classes
- Apply
- def tuple2[A, B](fa: => F[A], fb: => F[B]): F[(A, B)]
- Definition Classes
- Apply
- def tuple3[A, B, C](fa: => F[A], fb: => F[B], fc: => F[C]): F[(A, B, C)]
- Definition Classes
- Apply
- 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
- 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
- def unfoldrOpt[S, A, B](seed: S)(f: (S) => Maybe[(F[A], S)])(implicit R: Reducer[A, B]): Maybe[F[B]]
Unfold
seedto the right and combine effects left-to-right, using the given Reducer to combine values. - def unlessM[A](cond: Boolean)(f: => F[A]): F[Unit]
Returns the given argument if
condisfalse, otherwise, unit lifted into F.Returns the given argument if
condisfalse, otherwise, unit lifted into F.- Definition Classes
- Applicative
- def void[A](fa: F[A]): F[Unit]
Empty
faof meaningful pure values, preserving its structure.Empty
faof meaningful pure values, preserving its structure.- Definition Classes
- Functor
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def whenM[A](cond: Boolean)(f: => F[A]): F[Unit]
Returns the given argument if
condistrue, otherwise, unit lifted into F.Returns the given argument if
condistrue, otherwise, unit lifted into F.- Definition Classes
- Applicative
- 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 anF[B]ifAis a subtype ofB.Functors are covariant by nature, so we can treat an
F[A]as anF[B]ifAis a subtype ofB.- Definition Classes
- Functor
- final def xderiving0[Z](z: => Z): F[Z]
- Definition Classes
- InvariantApplicative
- final def xderiving1[Z, A1](f: (A1) => Z, g: (Z) => A1)(implicit a1: F[A1]): F[Z]
- Definition Classes
- InvariantApplicative
- final def xderiving2[Z, A1, A2](f: (A1, A2) => Z, g: (Z) => (A1, A2))(implicit a1: F[A1], a2: F[A2]): F[Z]
- Definition Classes
- InvariantApplicative
- final def xderiving3[Z, A1, A2, A3](f: (A1, A2, A3) => Z, g: (Z) => (A1, A2, A3))(implicit a1: F[A1], a2: F[A2], a3: F[A3]): F[Z]
- Definition Classes
- InvariantApplicative
- final def xderiving4[Z, A1, A2, A3, A4](f: (A1, A2, A3, A4) => Z, g: (Z) => (A1, A2, A3, A4))(implicit a1: F[A1], a2: F[A2], a3: F[A3], a4: F[A4]): F[Z]
- Definition Classes
- InvariantApplicative
- def xmap[A, B](ma: F[A], f: (A) => B, g: (B) => A): F[B]
Converts
mato a value of typeF[B]using the provided functionsfandg.Converts
mato a value of typeF[B]using the provided functionsfandg.- Definition Classes
- IsomorphismInvariantFunctor → InvariantFunctor
- def xmapb[A, B](ma: F[A])(b: Bijection[A, B]): F[B]
Converts
mato a value of typeF[B]using the provided bijection.Converts
mato a value of typeF[B]using the provided bijection.- Definition Classes
- InvariantFunctor
- def xmapi[A, B](ma: F[A])(iso: Isomorphism.<=>[A, B]): F[B]
Converts
mato a value of typeF[B]using the provided isomorphism.Converts
mato a value of typeF[B]using the provided isomorphism.- Definition Classes
- InvariantFunctor
- def xproduct0[Z](z: => Z): F[Z]
- Definition Classes
- IsomorphismApplicative → IsomorphismInvariantApplicative → Applicative → InvariantApplicative
- def xproduct1[Z, A1](a1: => F[A1])(f: (A1) => Z, g: (Z) => A1): F[Z]
- Definition Classes
- IsomorphismApplicative → Applicative → InvariantApplicative
- def xproduct2[Z, A1, A2](a1: => F[A1], a2: => F[A2])(f: (A1, A2) => Z, g: (Z) => (A1, A2)): F[Z]
- Definition Classes
- IsomorphismApplicative → IsomorphismInvariantApplicative → Applicative → InvariantApplicative
- def xproduct3[Z, A1, A2, A3](a1: => F[A1], a2: => F[A2], a3: => F[A3])(f: (A1, A2, A3) => Z, g: (Z) => (A1, A2, A3)): F[Z]
- Definition Classes
- IsomorphismApplicative → Applicative → InvariantApplicative
- def xproduct4[Z, A1, A2, A3, A4](a1: => F[A1], a2: => F[A2], a3: => F[A3], a4: => F[A4])(f: (A1, A2, A3, A4) => Z, g: (Z) => (A1, A2, A3, A4)): F[Z]
- Definition Classes
- IsomorphismApplicative → Applicative → InvariantApplicative