EitherT

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def either[F[_], A, B](d: \/[A, B])(implicit arg0: Applicative[F]): EitherT[F, A, B]

def eitherT[F[_], A, B](a: F[\/[A, B]]): EitherT[F, A, B]

implicit def eitherTBifoldable[F[_]](implicit F0: Foldable[F]): Bifoldable[[β$10$, γ$11$]EitherT[F, β$10$, γ$11$]]

implicit def eitherTBifunctor[F[_]](implicit F0: Functor[F]): Bifunctor[[β$8$, γ$9$]EitherT[F, β$8$, γ$9$]]

implicit def eitherTBindRec[F[_], E](implicit F0: Monad[F], B0: BindRec[F]): BindRec[[γ$2$]EitherT[F, E, γ$2$]]

implicit def eitherTBitraverse[F[_]](implicit F0: Traverse[F]): Bitraverse[[β$14$, γ$15$]EitherT[F, β$14$, γ$15$]]

implicit def eitherTEqual[F[_], A, B](implicit F0: Equal[F[\/[A, B]]]): Equal[EitherT[F, A, B]]

implicit def eitherTFoldable[F[_], L](implicit F0: Foldable[F]): Foldable[[γ$13$]EitherT[F, L, γ$13$]]

implicit def eitherTFunctor[F[_], L](implicit F0: Functor[F]): Functor[[γ$4$]EitherT[F, L, γ$4$]]

implicit def eitherTHoist[A]: Hoist[[α[_$1], β]EitherT[α, A, β]]

def eitherTMonad[F[_], L](implicit F0: Monad[F]): Monad[[γ$5$]EitherT[F, L, γ$5$]]

implicit def eitherTMonadError[F[_], E](implicit F0: Monad[F]): MonadError[[γ$6$]EitherT[F, E, γ$6$], E]

implicit def eitherTMonadPlus[F[_], L](implicit F0: Monad[F], L0: Monoid[L]): MonadPlus[[γ$12$]EitherT[F, L, γ$12$]]

implicit def eitherTParallelApplicative[F[_], E](implicit F0: Par[F]): Par[[γ$17$]EitherT[F, E, γ$17$]]

implicit def eitherTPlus[F[_], L](implicit F0: Monad[F], L0: Semigroup[L]): Plus[[γ$7$]EitherT[F, L, γ$7$]]

implicit def eitherTShow[F[_], A, B](implicit F0: Show[F[\/[A, B]]]): Show[EitherT[F, A, B]]

implicit def eitherTTraverse[F[_], L](implicit F0: Traverse[F]): Traverse[[γ$16$]EitherT[F, L, γ$16$]]

def eitherTU[FAB, AB, A0, B0](fab: FAB)(implicit u1: Unapply[Functor, FAB] { type A = AB }, u2: Unapply2[Bifunctor, AB] { ... /* 2 definitions in type refinement */ }, l: ===[AB, \/[A0, B0]]): EitherT[(u1)#M, A0, B0]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def fromDisjunction[F[_]]: FromDisjunctionAux[F]

def fromEither[F[_], A, B](e: F[Either[A, B]])(implicit F: Functor[F]): EitherT[F, A, B]

Construct a disjunction value from a standard scala.Either.

def fromTryCatchNonFatal[F[_], A](a: ⇒ F[A])(implicit F: Applicative[F]): EitherT[F, Throwable, A]

def fromTryCatchThrowable[F[_], A, B <: Throwable](a: ⇒ F[A])(implicit F: Applicative[F], nn: NotNothing[B], ex: ClassTag[B]): EitherT[F, B, A]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def leftT[F[_], A, B](fa: F[A])(implicit arg0: Functor[F]): EitherT[F, A, B]

def leftU[B]: EitherTLeft[B]

def monadListen[F[_], W, A](implicit ML0: MonadListen[F, W]): EitherTMonadListen[F, W, A]

def monadTell[F[_], W, A](implicit MT0: MonadTell[F, W]): EitherTMonadTell[F, W, A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pure[F[_], A, B](b: B)(implicit arg0: Applicative[F]): EitherT[F, A, B]

will be called right in scalaz 7.3

def pureLeft[F[_], A, B](a: A)(implicit arg0: Applicative[F]): EitherT[F, A, B]

will be called left in scalaz 7.3

def rightT[F[_], A, B](fb: F[B])(implicit arg0: Functor[F]): EitherT[F, A, B]

def rightU[A]: EitherTRight[A]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def left[F[_], A, B](a: F[A])(implicit F: Functor[F]): EitherT[F, A, B]

Construct a left disjunction value.

def right[F[_], A, B](b: F[B])(implicit F: Functor[F]): EitherT[F, A, B]

Construct a right disjunction value.