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

implicit def eitherTBifunctor[F[_]](implicit F0: Functor[F]): Bifunctor[[α, β]EitherT[F, α, β]]

implicit def eitherTBitraverse[F[_]](implicit F0: Traverse[F]): Bitraverse[[α, β]EitherT[F, α, β]]

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

implicit def eitherTFunctor[F[_], L](implicit F0: Functor[F]): Functor[[α]EitherT[F, L, α]]

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

implicit def eitherTMonad[F[_], L](implicit F0: Monad[F]): Monad[[α]EitherT[F, L, α]]

implicit def eitherTMonadError[F[_], E](implicit F0: Monad[F]): MonadError[[α, β]EitherT[F, α, β], E]

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

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

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

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: ClassManifest[B]): EitherT[F, B, A]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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

Construct a left disjunction value.

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]): MonadListen[[α, β]EitherT[[x]F[α, x], A, β], W]

def monadTell[F[_, _], W, A](implicit MT0: MonadTell[F, W]): MonadTell[[α, β]EitherT[[x]F[α, x], A, β], W]

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]

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

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

Construct a right disjunction value.

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 fromTryCatch[F[_], A](a: ⇒ F[A])(implicit F: Applicative[F]): EitherT[F, Throwable, A]

Evaluate the given value, which might throw an exception.