IsomorphismMonadControlIO

Type Members

trait ApplicativeLaw extends Applicative.ApplyLaw

Definition Classes
Applicative
trait ApplyLaw extends Apply.FunctorLaw

Definition Classes
Apply
trait BindLaw extends Bind.ApplyLaw

Definition Classes
Bind
trait FlippedApply extends Apply[F]

Attributes
protected[this]
Definition Classes
Apply
trait FunctorLaw extends Functor.InvariantFunctorLaw

Definition Classes
Functor
trait InvariantFunctorLaw extends AnyRef

Definition Classes
InvariantFunctor
trait MonadLaw extends Monad.ApplicativeLaw with Monad.BindLaw

Definition Classes
Monad

Abstract Value Members

implicit abstract def G: MonadControlIO[G]

Definition Classes
IsomorphismMonadControlIO → IsomorphismMonad → IsomorphismBind → IsomorphismApplicative → IsomorphismApplicativeDivisible → IsomorphismApply → IsomorphismApplyDivide → IsomorphismFunctor → IsomorphismInvariantFunctor → IsomorphismLiftControlIO
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]

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]

Definition Classes
Apply
val applicativeDivisibleSyntax: ApplicativeDivisibleSyntax[F]

Definition Classes
ApplicativeDivisible
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]

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
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[α], α]]

Definition Classes
Apply
val applyDivideSyntax: ApplyDivideSyntax[F]

Definition Classes
ApplyDivide
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[α, β]]]

Definition Classes
Functor
def bind[A, B](fa: F[A])(f: (A) ⇒ F[B]): F[B]

Definition Classes
IsomorphismBind → Bind
def bindLaw: BindLaw

Definition Classes
Bind
val bindSyntax: BindSyntax[F]

Definition Classes
Bind
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]F[G[α]]]

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

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

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]

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

Definition Classes
Apply
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def filterM[A](l: IList[A])(f: (A) ⇒ F[Boolean]): F[IList[A]]

Definition Classes
Applicative
def filterM[A](l: List[A])(f: (A) ⇒ F[Boolean]): F[List[A]]

Definition Classes
Applicative
def finalize(): Unit

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

Definition Classes
Applicative → Apply
def forever[A, B](fa: F[A]): F[B]

Definition Classes
Apply
def fpair[A](fa: F[A]): F[(A, A)]

Definition Classes
Functor
def fproduct[A, B](fa: F[A])(f: (A) ⇒ B): F[(A, B)]

Definition Classes
Functor
def functorLaw: FunctorLaw

Definition Classes
Functor
val functorSyntax: FunctorSyntax[F]

Definition Classes
Functor
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]F[G[α]]]

Definition Classes
Functor
def ifM[B](value: F[Boolean], ifTrue: ⇒ F[B], ifFalse: ⇒ F[B]): F[B]

Definition Classes
Bind
def invariantFunctorLaw: InvariantFunctorLaw

Definition Classes
InvariantFunctor
val invariantFunctorSyntax: InvariantFunctorSyntax[F]

Definition Classes
InvariantFunctor
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterateUntil[A](f: F[A])(p: (A) ⇒ Boolean): F[A]

Definition Classes
Monad
def iterateWhile[A](f: F[A])(p: (A) ⇒ Boolean): F[A]

Definition Classes
Monad
def join[A](ffa: F[F[A]]): F[A]

Definition Classes
Bind
def lift[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[B]

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 liftControlIO[A](f: (RunInBase[F, IO]) ⇒ IO[A]): F[A]

Definition Classes
IsomorphismLiftControlIO → LiftControlIO
val liftControlIOSyntax: LiftControlIOSyntax[F]

Definition Classes
LiftControlIO
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]

Definition Classes
IsomorphismFunctor → Functor
def mapply[A, B](a: A)(f: F[(A) ⇒ B]): F[B]

Definition Classes
Functor
val monadControlIOSyntax: MonadControlIOSyntax[F]

Definition Classes
MonadControlIO
def monadLaw: MonadLaw

Definition Classes
Monad
val monadSyntax: MonadSyntax[F]

Definition Classes
Monad
def mproduct[A, B](fa: F[A])(f: (A) ⇒ F[B]): F[(A, B)]

Definition Classes
Bind
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def point[A](a: ⇒ A): F[A]

Definition Classes
IsomorphismApplicative → Applicative
def product[G[_]](implicit G0: Monad[G]): Monad[[α](F[α], G[α])]

Definition Classes
Monad
def product[G[_]](implicit G0: Bind[G]): Bind[[α](F[α], G[α])]

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

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

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

Definition Classes
Functor
final def pure[A](a: ⇒ A): F[A]

Definition Classes
Applicative
def replicateM[A](n: Int, fa: F[A]): F[IList[A]]

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

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)]

Definition Classes
Functor
def strengthR[A, B](f: F[A], b: B): F[(A, B)]

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]]

Definition Classes
Apply
def unlessM[A](cond: Boolean)(f: ⇒ F[A]): F[Unit]

Definition Classes
Applicative
def untilM[G[_], A](f: F[A], cond: ⇒ F[Boolean])(implicit G: MonadPlus[G]): F[G[A]]

Definition Classes
Monad
def untilM_[A](f: F[A], cond: ⇒ F[Boolean]): F[Unit]

Definition Classes
Monad
def void[A](fa: F[A]): F[Unit]

Definition Classes
Functor
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )
def whenM[A](cond: Boolean)(f: ⇒ F[A]): F[Unit]

Definition Classes
Applicative
def whileM[G[_], A](p: F[Boolean], body: ⇒ F[A])(implicit G: MonadPlus[G]): F[G[A]]

Definition Classes
Monad
def whileM_[A](p: F[Boolean], body: ⇒ F[A]): F[Unit]

Definition Classes
Monad
def widen[A, B](fa: F[A])(implicit ev: <~<[A, B]): F[B]

Definition Classes
Functor
final def xderiving0[Z](z: Z): F[Z]

Definition Classes
ApplicativeDivisible
final def xderiving1[Z, A1](f: (A1) ⇒ Z, g: (Z) ⇒ A1)(implicit a1: F[A1]): F[Z]

Definition Classes
ApplyDivide
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
ApplyDivide
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
ApplyDivide
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
ApplyDivide
def xmap[A, B](ma: F[A], f: (A) ⇒ B, g: (B) ⇒ A): F[B]

Definition Classes
IsomorphismInvariantFunctor → InvariantFunctor
def xmapb[A, B](ma: F[A])(b: Bijection[A, B]): F[B]

Definition Classes
InvariantFunctor
def xmapi[A, B](ma: F[A])(iso: Isomorphism.<=>[A, B]): F[B]

Definition Classes
InvariantFunctor
def xproduct0[Z](f: ⇒ Z): F[Z]

Definition Classes
IsomorphismApplicativeDivisible → ApplicativeDivisible
def xproduct1[Z, A1](a1: F[A1])(f: (A1) ⇒ Z, g: (Z) ⇒ A1): F[Z]

Definition Classes
ApplyDivide
def xproduct2[Z, A1, A2](a1: ⇒ F[A1], a2: ⇒ F[A2])(f: (A1, A2) ⇒ Z, g: (Z) ⇒ (A1, A2)): F[Z]

Definition Classes
IsomorphismApplyDivide → ApplyDivide
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
IsomorphismApplyDivide → ApplyDivide
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
IsomorphismApplyDivide → ApplyDivide

Related Doc: package effect

trait IsomorphismMonadControlIO[F[_], G[_]] extends MonadControlIO[F] with IsomorphismLiftControlIO[F, G] with IsomorphismMonad[F, G]

Type Members

trait ApplicativeLaw extends Applicative.ApplyLaw

trait ApplyLaw extends Apply.FunctorLaw

trait BindLaw extends Bind.ApplyLaw

trait FlippedApply extends Apply[F]

trait FunctorLaw extends Functor.InvariantFunctorLaw

trait InvariantFunctorLaw extends AnyRef

trait MonadLaw extends Monad.ApplicativeLaw with Monad.BindLaw

Abstract Value Members

implicit abstract def G: MonadControlIO[G]

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

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ap[A, B](fa: ⇒ F[A])(f: ⇒ F[(A) ⇒ B]): F[B]

def ap2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: F[(A, B) ⇒ C]): F[C]

def ap3[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: F[(A, B, C) ⇒ D]): F[D]

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]

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]

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]

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]

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]

def apF[A, B](f: ⇒ F[(A) ⇒ B]): (F[A]) ⇒ F[B]

val applicativeDivisibleSyntax: ApplicativeDivisibleSyntax[F]

def applicativeLaw: ApplicativeLaw

val applicativeSyntax: ApplicativeSyntax[F]

def apply[A, B](fa: F[A])(f: (A) ⇒ B): F[B]

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]

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]

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]

def apply2[A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: (A, B) ⇒ C): F[C]

def apply3[A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: (A, B, C) ⇒ D): F[D]

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]

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]

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]

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]

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]

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]

def applyApplicative: Applicative[[α]\/[F[α], α]]

val applyDivideSyntax: ApplyDivideSyntax[F]

def applyLaw: ApplyLaw

val applySyntax: ApplySyntax[F]

final def applying1[Z, A1](f: (A1) ⇒ Z)(implicit a1: F[A1]): F[Z]

final def applying2[Z, A1, A2](f: (A1, A2) ⇒ Z)(implicit a1: F[A1], a2: F[A2]): F[Z]

final def applying3[Z, A1, A2, A3](f: (A1, A2, A3) ⇒ Z)(implicit a1: F[A1], a2: F[A2], a3: F[A3]): F[Z]

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]

final def asInstanceOf[T0]: T0

def bicompose[G[_, _]](implicit arg0: Bifunctor[G]): Bifunctor[[α, β]F[G[α, β]]]

def bind[A, B](fa: F[A])(f: (A) ⇒ F[B]): F[B]

def bindLaw: BindLaw

val bindSyntax: BindSyntax[F]

def clone(): AnyRef

def compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]F[G[α]]]

def compose[G[_]](implicit G0: Apply[G]): Apply[[α]F[G[α]]]

def compose[G[_]](implicit G0: Functor[G]): Functor[[α]F[G[α]]]

def counzip[A, B](a: \/[F[A], F[B]]): F[\/[A, B]]

def discardLeft[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[B]

def discardRight[A, B](fa: ⇒ F[A], fb: ⇒ F[B]): F[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filterM[A](l: IList[A])(f: (A) ⇒ F[Boolean]): F[IList[A]]

def filterM[A](l: List[A])(f: (A) ⇒ F[Boolean]): F[List[A]]

def finalize(): Unit

def flip: Applicative[F]

def forever[A, B](fa: F[A]): F[B]

def fpair[A](fa: F[A]): F[(A, A)]

def fproduct[A, B](fa: F[A])(f: (A) ⇒ B): F[(A, B)]

def functorLaw: FunctorLaw

val functorSyntax: FunctorSyntax[F]

final def getClass(): Class[_]

def hashCode(): Int

def icompose[G[_]](implicit G0: Contravariant[G]): Contravariant[[α]F[G[α]]]

def ifM[B](value: F[Boolean], ifTrue: ⇒ F[B], ifFalse: ⇒ F[B]): F[B]

def invariantFunctorLaw: InvariantFunctorLaw

val invariantFunctorSyntax: InvariantFunctorSyntax[F]

final def isInstanceOf[T0]: Boolean