EitherTListenableMonadWriter

implicit abstract def MW: ListenableMonadWriter[F, W]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

implicit def F: MonadWriter[F, W]

implicit def W: Monoid[W]

def ap[A, B](fa: ⇒ EitherT[[+α]F[W, α], A, A])(f: ⇒ EitherT[[+α]F[W, α], A, (A) ⇒ B]): EitherT[[+α]F[W, α], A, B]

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

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

def ap4[A, B, C, D, E](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D])(f: EitherT[[+x]F[W, x], A, (A, B, C, D) ⇒ E]): EitherT[[+x]F[W, x], A, E]

def ap5[A, B, C, D, E, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E])(f: EitherT[[+x]F[W, x], A, (A, B, C, D, E) ⇒ R]): EitherT[[+x]F[W, x], A, R]

def ap6[A, B, C, D, E, FF, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E], ff: ⇒ EitherT[[+x]F[W, x], A, FF])(f: EitherT[[+x]F[W, x], A, (A, B, C, D, E, FF) ⇒ R]): EitherT[[+x]F[W, x], A, R]

def ap7[A, B, C, D, E, FF, G, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E], ff: ⇒ EitherT[[+x]F[W, x], A, FF], fg: ⇒ EitherT[[+x]F[W, x], A, G])(f: EitherT[[+x]F[W, x], A, (A, B, C, D, E, FF, G) ⇒ R]): EitherT[[+x]F[W, x], A, R]

def ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E], ff: ⇒ EitherT[[+x]F[W, x], A, FF], fg: ⇒ EitherT[[+x]F[W, x], A, G], fh: ⇒ EitherT[[+x]F[W, x], A, H])(f: EitherT[[+x]F[W, x], A, (A, B, C, D, E, FF, G, H) ⇒ R]): EitherT[[+x]F[W, x], A, R]

def apF[A, B](f: ⇒ EitherT[[+x]F[W, x], A, (A) ⇒ B]): (EitherT[[+x]F[W, x], A, A]) ⇒ EitherT[[+x]F[W, x], A, B]

def applicativeLaw: ApplicativeLaw

val applicativeSyntax: ApplicativeSyntax[[+x]EitherT[[+x]F[W, x], A, x]]

implicit def apply[M[+_]](implicit arg0: Monad[M]): Monad[[α]EitherT[M, A, α]]

def apply[A, B](fa: EitherT[[+x]F[W, x], A, A])(f: (A) ⇒ B): EitherT[[+x]F[W, x], A, B]

Alias for map.

def apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E], ff: ⇒ EitherT[[+x]F[W, x], A, FF], fg: ⇒ EitherT[[+x]F[W, x], A, G], fh: ⇒ EitherT[[+x]F[W, x], A, H], fi: ⇒ EitherT[[+x]F[W, x], A, I], fj: ⇒ EitherT[[+x]F[W, x], A, J])(f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): EitherT[[+x]F[W, x], A, R]

def apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E], ff: ⇒ EitherT[[+x]F[W, x], A, FF], fg: ⇒ EitherT[[+x]F[W, x], A, G], fh: ⇒ EitherT[[+x]F[W, x], A, H], fi: ⇒ EitherT[[+x]F[W, x], A, I], fj: ⇒ EitherT[[+x]F[W, x], A, J], fk: ⇒ EitherT[[+x]F[W, x], A, K])(f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): EitherT[[+x]F[W, x], A, R]

def apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E], ff: ⇒ EitherT[[+x]F[W, x], A, FF], fg: ⇒ EitherT[[+x]F[W, x], A, G], fh: ⇒ EitherT[[+x]F[W, x], A, H], fi: ⇒ EitherT[[+x]F[W, x], A, I], fj: ⇒ EitherT[[+x]F[W, x], A, J], fk: ⇒ EitherT[[+x]F[W, x], A, K], fl: ⇒ EitherT[[+x]F[W, x], A, L])(f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): EitherT[[+x]F[W, x], A, R]

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

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

def apply4[A, B, C, D, E](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D])(f: (A, B, C, D) ⇒ E): EitherT[[+x]F[W, x], A, E]

def apply5[A, B, C, D, E, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E])(f: (A, B, C, D, E) ⇒ R): EitherT[[+x]F[W, x], A, R]

def apply6[A, B, C, D, E, FF, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E], ff: ⇒ EitherT[[+x]F[W, x], A, FF])(f: (A, B, C, D, E, FF) ⇒ R): EitherT[[+x]F[W, x], A, R]

def apply7[A, B, C, D, E, FF, G, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E], ff: ⇒ EitherT[[+x]F[W, x], A, FF], fg: ⇒ EitherT[[+x]F[W, x], A, G])(f: (A, B, C, D, E, FF, G) ⇒ R): EitherT[[+x]F[W, x], A, R]

def apply8[A, B, C, D, E, FF, G, H, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E], ff: ⇒ EitherT[[+x]F[W, x], A, FF], fg: ⇒ EitherT[[+x]F[W, x], A, G], fh: ⇒ EitherT[[+x]F[W, x], A, H])(f: (A, B, C, D, E, FF, G, H) ⇒ R): EitherT[[+x]F[W, x], A, R]

def apply9[A, B, C, D, E, FF, G, H, I, R](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E], ff: ⇒ EitherT[[+x]F[W, x], A, FF], fg: ⇒ EitherT[[+x]F[W, x], A, G], fh: ⇒ EitherT[[+x]F[W, x], A, H], fi: ⇒ EitherT[[+x]F[W, x], A, I])(f: (A, B, C, D, E, FF, G, H, I) ⇒ R): EitherT[[+x]F[W, x], A, R]

val applySyntax: ApplySyntax[[+x]EitherT[[+x]F[W, x], A, x]]

final def asInstanceOf[T0]: T0

def bind[A, B](fa: EitherT[[+α]F[W, α], A, A])(f: (A) ⇒ EitherT[[+α]F[W, α], A, B]): EitherT[[+α]F[W, α], A, B]

Equivalent to join(map(fa)(f)).

val bindSyntax: BindSyntax[[+x]EitherT[[+x]F[W, x], A, x]]

def clone(): AnyRef

def compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]EitherT[[+x]F[W, x], A, G[α]]]

The composition of Applicatives F and G, [x]F[G[x]], is an Applicative

def compose[G[_]](implicit G0: Pointed[G]): Pointed[[α]EitherT[[+x]F[W, x], A, G[α]]]

The composition of Pointeds F and G, [x]F[G[x]], is a Pointed

def compose[G[_]](implicit G0: Apply[G]): Apply[[α]EitherT[[+x]F[W, x], A, G[α]]]

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

def compose[G[_]](implicit G0: Functor[G]): Functor[[α]EitherT[[+x]F[W, x], A, G[α]]]

The composition of Functors F and G, [x]F[G[x]], is a Functor

def counzip[A, B](a: \/[EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B]]): EitherT[[+x]F[W, x], A, \/[A, B]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filterM[A](l: List[A])(f: (A) ⇒ EitherT[[+x]F[W, x], A, Boolean]): EitherT[[+x]F[W, x], A, List[A]]

def finalize(): Unit

def flip: Applicative[[+x]EitherT[[+x]F[W, x], A, x]]

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

def fpair[A](fa: EitherT[[+x]F[W, x], A, A]): EitherT[[+x]F[W, x], A, (A, A)]

Twin all As in fa.

def functorLaw: FunctorLaw

val functorSyntax: FunctorSyntax[[+x]EitherT[[+x]F[W, x], A, x]]

final def getClass(): Class[_]

def hashCode(): Int

def hoist[M[+_], N[+_]](f: ~>[M, N])(implicit M: Monad[M]): ~>[[α]EitherT[M, A, α], [α]EitherT[N, A, α]]

def ifM[B](value: EitherT[[+x]F[W, x], A, Boolean], ifTrue: ⇒ EitherT[[+x]F[W, x], A, B], ifFalse: ⇒ EitherT[[+x]F[W, x], A, B]): EitherT[[+x]F[W, x], A, B]

if lifted into a binding.

final def isInstanceOf[T0]: Boolean

def join[A](ffa: EitherT[[+x]F[W, x], A, EitherT[[+x]F[W, x], A, A]]): EitherT[[+x]F[W, x], A, A]

Sequence the inner F of FFA after the outer F, forming a single F[A].

def left[B](v: ⇒ A): EitherT[[+α]F[W, α], A, B]

def lift[A, B](f: (A) ⇒ B): (EitherT[[+x]F[W, x], A, A]) ⇒ EitherT[[+x]F[W, x], A, B]

Lift f into F.

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): (EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B], EitherT[[+x]F[W, x], A, C], EitherT[[+x]F[W, x], A, D], EitherT[[+x]F[W, x], A, E], EitherT[[+x]F[W, x], A, FF], EitherT[[+x]F[W, x], A, G], EitherT[[+x]F[W, x], A, H], EitherT[[+x]F[W, x], A, I], EitherT[[+x]F[W, x], A, J]) ⇒ EitherT[[+x]F[W, x], A, R]

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): (EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B], EitherT[[+x]F[W, x], A, C], EitherT[[+x]F[W, x], A, D], EitherT[[+x]F[W, x], A, E], EitherT[[+x]F[W, x], A, FF], EitherT[[+x]F[W, x], A, G], EitherT[[+x]F[W, x], A, H], EitherT[[+x]F[W, x], A, I], EitherT[[+x]F[W, x], A, J], EitherT[[+x]F[W, x], A, K]) ⇒ EitherT[[+x]F[W, x], A, R]

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): (EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B], EitherT[[+x]F[W, x], A, C], EitherT[[+x]F[W, x], A, D], EitherT[[+x]F[W, x], A, E], EitherT[[+x]F[W, x], A, FF], EitherT[[+x]F[W, x], A, G], EitherT[[+x]F[W, x], A, H], EitherT[[+x]F[W, x], A, I], EitherT[[+x]F[W, x], A, J], EitherT[[+x]F[W, x], A, K], EitherT[[+x]F[W, x], A, L]) ⇒ EitherT[[+x]F[W, x], A, R]

def lift2[A, B, C](f: (A, B) ⇒ C): (EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B]) ⇒ EitherT[[+x]F[W, x], A, C]

def lift3[A, B, C, D](f: (A, B, C) ⇒ D): (EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B], EitherT[[+x]F[W, x], A, C]) ⇒ EitherT[[+x]F[W, x], A, D]

def lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B], EitherT[[+x]F[W, x], A, C], EitherT[[+x]F[W, x], A, D]) ⇒ EitherT[[+x]F[W, x], A, E]

def lift5[A, B, C, D, E, R](f: (A, B, C, D, E) ⇒ R): (EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B], EitherT[[+x]F[W, x], A, C], EitherT[[+x]F[W, x], A, D], EitherT[[+x]F[W, x], A, E]) ⇒ EitherT[[+x]F[W, x], A, R]

def lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) ⇒ R): (EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B], EitherT[[+x]F[W, x], A, C], EitherT[[+x]F[W, x], A, D], EitherT[[+x]F[W, x], A, E], EitherT[[+x]F[W, x], A, FF]) ⇒ EitherT[[+x]F[W, x], A, R]

def lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) ⇒ R): (EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B], EitherT[[+x]F[W, x], A, C], EitherT[[+x]F[W, x], A, D], EitherT[[+x]F[W, x], A, E], EitherT[[+x]F[W, x], A, FF], EitherT[[+x]F[W, x], A, G]) ⇒ EitherT[[+x]F[W, x], A, R]

def lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) ⇒ R): (EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B], EitherT[[+x]F[W, x], A, C], EitherT[[+x]F[W, x], A, D], EitherT[[+x]F[W, x], A, E], EitherT[[+x]F[W, x], A, FF], EitherT[[+x]F[W, x], A, G], EitherT[[+x]F[W, x], A, H]) ⇒ EitherT[[+x]F[W, x], A, R]

def lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) ⇒ R): (EitherT[[+x]F[W, x], A, A], EitherT[[+x]F[W, x], A, B], EitherT[[+x]F[W, x], A, C], EitherT[[+x]F[W, x], A, D], EitherT[[+x]F[W, x], A, E], EitherT[[+x]F[W, x], A, FF], EitherT[[+x]F[W, x], A, G], EitherT[[+x]F[W, x], A, H], EitherT[[+x]F[W, x], A, I]) ⇒ EitherT[[+x]F[W, x], A, R]

def liftM[M[+_], B](mb: M[B])(implicit M: Monad[M]): EitherT[M, A, B]

def listen[B](ma: EitherT[[+α]F[W, α], A, B]): EitherT[[+α]F[W, α], A, (B, W)]

val listenableMonadWriterSyntax: ListenableMonadWriterSyntax[[+α, +β]EitherT[[+x]F[α, x], A, β], W]

def map[A, B](fa: EitherT[[+α]F[W, α], A, A])(f: (A) ⇒ B): EitherT[[+α]F[W, α], A, B]

Lift f into F and apply to F[A].

def mapply[A, B](a: A)(f: EitherT[[+x]F[W, x], A, (A) ⇒ B]): EitherT[[+x]F[W, x], A, B]

Lift apply(a), and apply the result to f.

def monadLaw: MonadLaw

val monadSyntax: MonadSyntax[[+x]EitherT[[+x]F[W, x], A, x]]

val monadWriterSyntax: MonadWriterSyntax[[+α, +β]EitherT[[+x]F[α, x], A, β], W]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pass[A](ma: EitherT[[+x]F[W, x], A, (A, (W) ⇒ W)]): EitherT[[+x]F[W, x], A, A]

def point[A](a: ⇒ A): EitherT[[+α]F[W, α], A, A]

val pointedSyntax: PointedSyntax[[+x]EitherT[[+x]F[W, x], A, x]]

def product[G[_]](implicit G0: Applicative[G]): Applicative[[α](EitherT[[+x]F[W, x], A, α], G[α])]

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

def product[G[_]](implicit G0: Pointed[G]): Pointed[[α](EitherT[[+x]F[W, x], A, α], G[α])]

The product of Pointeds F and G, [x](F[x], G[x]]), is a Pointed

def product[G[_]](implicit G0: Apply[G]): Apply[[α](EitherT[[+x]F[W, x], A, α], G[α])]

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

def product[G[_]](implicit G0: Functor[G]): Functor[[α](EitherT[[+x]F[W, x], A, α], G[α])]

The product of Functors F and G, [x](F[x], G[x]]), is a Functor

def pure[A](a: ⇒ A): EitherT[[+x]F[W, x], A, A]

alias for point

def replicateM[A](n: Int, fa: EitherT[[+x]F[W, x], A, A]): EitherT[[+x]F[W, x], A, List[A]]

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

def replicateM_[A](n: Int, fa: EitherT[[+x]F[W, x], A, A]): EitherT[[+x]F[W, x], A, Unit]

Performs the action n times, returning nothing.

def right[B](v: ⇒ B): EitherT[[+α]F[W, α], A, B]

def sequence[A, G[_]](as: G[EitherT[[+x]F[W, x], A, A]])(implicit arg0: Traverse[G]): EitherT[[+x]F[W, x], A, G[A]]

def strengthL[A, B](a: A, f: EitherT[[+x]F[W, x], A, B]): EitherT[[+x]F[W, x], A, (A, B)]

Inject a to the left of Bs in f.

def strengthR[A, B](f: EitherT[[+x]F[W, x], A, A], b: B): EitherT[[+x]F[W, x], A, (A, B)]

Inject b to the right of As in f.

final def synchronized[T0](arg0: ⇒ T0): T0

def tell(w: W): EitherT[[+x]F[W, x], A, Unit]

def toString(): String

def traverse[A, G[_], B](value: G[A])(f: (A) ⇒ EitherT[[+x]F[W, x], A, B])(implicit G: Traverse[G]): EitherT[[+x]F[W, x], A, G[B]]

def tuple2[A, B](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B]): EitherT[[+x]F[W, x], A, (A, B)]

def tuple3[A, B, C](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: EitherT[[+x]F[W, x], A, C]): EitherT[[+x]F[W, x], A, (A, B, C)]

def tuple4[A, B, C, D](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D]): EitherT[[+x]F[W, x], A, (A, B, C, D)]

def tuple5[A, B, C, D, E](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D], fe: ⇒ EitherT[[+x]F[W, x], A, E]): EitherT[[+x]F[W, x], A, (A, B, C, D, E)]

def void[A](fa: EitherT[[+x]F[W, x], A, A]): EitherT[[+x]F[W, x], A, Unit]

Empty fa of meaningful pure values, preserving its structure.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def writer[B](v: (W, B)): EitherT[[+α]F[W, α], A, B]

def zip: Zip[[+x]EitherT[[+x]F[W, x], A, x]]

def map2[A, B, C](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B])(f: (A, B) ⇒ C): EitherT[[+x]F[W, x], A, C]

def map3[A, B, C, D](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C])(f: (A, B, C) ⇒ D): EitherT[[+x]F[W, x], A, D]

def map4[A, B, C, D, E](fa: ⇒ EitherT[[+x]F[W, x], A, A], fb: ⇒ EitherT[[+x]F[W, x], A, B], fc: ⇒ EitherT[[+x]F[W, x], A, C], fd: ⇒ EitherT[[+x]F[W, x], A, D])(f: (A, B, C, D) ⇒ E): EitherT[[+x]F[W, x], A, E]