final case class EitherT[F[_], A, B](value: F[Either[A, B]]) extends Product with Serializable

Transformer for Either, allowing the effect of an arbitrary type constructor F to be combined with the fail-fast effect of Either.

EitherT[F, A, B] wraps a value of type F[Either[A, B]]. An F[C] can be lifted in to EitherT[F, A, C] via EitherT.right, and lifted in to a EitherT[F, C, B] via EitherT.left.

Linear Supertypes
Serializable, Serializable, Product, Equals, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. EitherT
  2. Serializable
  3. Serializable
  4. Product
  5. Equals
  6. AnyRef
  7. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new EitherT(value: F[Either[A, B]])

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def ===(that: EitherT[F, A, B])(implicit eq: Eq[F[Either[A, B]]]): Boolean
  5. def applyAlt[D](ff: EitherT[F, A, (B) ⇒ D])(implicit F: Apply[F]): EitherT[F, A, D]
  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def biSemiflatMap[C, D](fa: (A) ⇒ F[C], fb: (B) ⇒ F[D])(implicit F: Monad[F]): EitherT[F, C, D]

    Combine leftSemiflatMap and semiflatMap together.

    Combine leftSemiflatMap and semiflatMap together.

    Example:

    scala> import cats.implicits._
scala> import cats.data.EitherT

scala> val eitherT: EitherT[List, String, Int] = EitherT[List, String, Int](List(Left("abc"), Right(123)))
scala> eitherT.biSemiflatMap(string => List(string.length), int => List(int.toFloat))
res0: cats.data.EitherT[List,Int,Float] = EitherT(List(Left(3), Right(123.0)))
  8. def biflatMap[AA >: A, BB >: B](fa: (A) ⇒ EitherT[F, AA, BB], fb: (B) ⇒ EitherT[F, AA, BB])(implicit F: FlatMap[F]): EitherT[F, AA, BB]
  9. def bimap[C, D](fa: (A) ⇒ C, fb: (B) ⇒ D)(implicit F: Functor[F]): EitherT[F, C, D]
  10. def bitraverse[G[_], C, D](f: (A) ⇒ G[C], g: (B) ⇒ G[D])(implicit traverseF: Traverse[F], applicativeG: Applicative[G]): G[EitherT[F, C, D]]
  11. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  12. def collectRight(implicit FA: Alternative[F], FM: Monad[F]): F[B]
  13. def combine(that: EitherT[F, A, B])(implicit F: Apply[F], B: Semigroup[B]): EitherT[F, A, B]

    Similar to Either#combine but mapped over an F context.

    Similar to Either#combine but mapped over an F context.

    Examples:

    scala> import cats.data.EitherT
scala> import cats.implicits._
scala> val l1: EitherT[Option, String, Int] = EitherT.left(Some("error 1"))
scala> val l2: EitherT[Option, String, Int] = EitherT.left(Some("error 2"))
scala> val r3: EitherT[Option, String, Int] = EitherT.right(Some(3))
scala> val r4: EitherT[Option, String, Int] = EitherT.right(Some(4))
scala> val noneEitherT: EitherT[Option, String, Int] = EitherT.left(None)

scala> l1 combine l2
res0: EitherT[Option, String, Int] = EitherT(Some(Left(error 1)))

scala> l1 combine r3
res1: EitherT[Option, String, Int] = EitherT(Some(Left(error 1)))

scala> r3 combine l1
res2: EitherT[Option, String, Int] = EitherT(Some(Left(error 1)))

scala> r3 combine r4
res3: EitherT[Option, String, Int] = EitherT(Some(Right(7)))

scala> l1 combine noneEitherT
res4: EitherT[Option, String, Int] = EitherT(None)

scala> noneEitherT combine l1
res5: EitherT[Option, String, Int] = EitherT(None)

scala> r3 combine noneEitherT
res6: EitherT[Option, String, Int] = EitherT(None)

scala> noneEitherT combine r4
res7: EitherT[Option, String, Int] = EitherT(None)
  14. def compare(that: EitherT[F, A, B])(implicit o: Order[F[Either[A, B]]]): Int
  15. def ensure[AA >: A](onFailure: ⇒ AA)(f: (B) ⇒ Boolean)(implicit F: Functor[F]): EitherT[F, AA, B]
  16. def ensureOr[AA >: A](onFailure: (B) ⇒ AA)(f: (B) ⇒ Boolean)(implicit F: Functor[F]): EitherT[F, AA, B]
  17. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  18. def exists(f: (B) ⇒ Boolean)(implicit F: Functor[F]): F[Boolean]
  19. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  20. def flatMap[AA >: A, D](f: (B) ⇒ EitherT[F, AA, D])(implicit F: Monad[F]): EitherT[F, AA, D]
  21. def flatMapF[AA >: A, D](f: (B) ⇒ F[Either[AA, D]])(implicit F: Monad[F]): EitherT[F, AA, D]
  22. def fold[C](fa: (A) ⇒ C, fb: (B) ⇒ C)(implicit F: Functor[F]): F[C]
  23. def foldLeft[C](c: C)(f: (C, B) ⇒ C)(implicit F: Foldable[F]): C
  24. def foldRight[C](lc: Eval[C])(f: (B, Eval[C]) ⇒ Eval[C])(implicit F: Foldable[F]): Eval[C]
  25. def forall(f: (B) ⇒ Boolean)(implicit F: Functor[F]): F[Boolean]
  26. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  27. def getOrElse[BB >: B](default: ⇒ BB)(implicit F: Functor[F]): F[BB]
  28. def getOrElseF[BB >: B](default: ⇒ F[BB])(implicit F: Monad[F]): F[BB]
  29. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  30. def isLeft(implicit F: Functor[F]): F[Boolean]
  31. def isRight(implicit F: Functor[F]): F[Boolean]
  32. def leftFlatMap[BB >: B, D](f: (A) ⇒ EitherT[F, D, BB])(implicit F: Monad[F]): EitherT[F, D, BB]
  33. def leftMap[C](f: (A) ⇒ C)(implicit F: Functor[F]): EitherT[F, C, B]
  34. def leftSemiflatMap[D](f: (A) ⇒ F[D])(implicit F: Monad[F]): EitherT[F, D, B]
  35. def map[D](f: (B) ⇒ D)(implicit F: Functor[F]): EitherT[F, A, D]
  36. def mapK[G[_]](f: ~>[F, G]): EitherT[G, A, B]

    Modify the context F using transformation f.

  37. def merge[AA >: A](implicit ev: <:<[B, AA], F: Functor[F]): F[AA]
  38. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  39. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  40. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  41. def orElse[AA, BB >: B](default: ⇒ EitherT[F, AA, BB])(implicit F: Monad[F]): EitherT[F, AA, BB]
  42. def partialCompare(that: EitherT[F, A, B])(implicit p: PartialOrder[F[Either[A, B]]]): Double
  43. def recover(pf: PartialFunction[A, B])(implicit F: Functor[F]): EitherT[F, A, B]
  44. def recoverWith(pf: PartialFunction[A, EitherT[F, A, B]])(implicit F: Monad[F]): EitherT[F, A, B]
  45. def rethrowT(implicit F: MonadError[F, A]): F[B]

    Inverse of MonadError#attemptT

  46. def semiflatMap[D](f: (B) ⇒ F[D])(implicit F: Monad[F]): EitherT[F, A, D]
  47. def show(implicit show: Show[F[Either[A, B]]]): String
  48. def subflatMap[AA >: A, D](f: (B) ⇒ Either[AA, D])(implicit F: Functor[F]): EitherT[F, AA, D]
  49. def swap(implicit F: Functor[F]): EitherT[F, B, A]
  50. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  51. def to[G[_]](implicit F: Functor[F], G: Alternative[G]): F[G[B]]
  52. def toNested: Nested[F, [β$2$]Either[A, β$2$], B]

    Transform this EitherT[F, A, B] into a Nested[F, Either[A, ?], B].

    Transform this EitherT[F, A, B] into a Nested[F, Either[A, ?], B].

    An example where toNested can be used, is to get the Apply.ap function with the behavior from the composed Apply instances from F and Either[A, ?], which is inconsistent with the behavior of the ap from Monad of EitherT.

    scala> import cats.data.EitherT
scala> import cats.implicits._
scala> val ff: EitherT[List, String, Int => String] =
     |   EitherT(List(Either.right(_.toString), Either.left("error")))
scala> val fa: EitherT[List, String, Int] =
     |   EitherT(List(Either.right(1), Either.right(2)))
scala> ff.ap(fa)
res0: EitherT[List,String,String] = EitherT(List(Right(1), Right(2), Left(error)))
scala> EitherT((ff.toNested).ap(fa.toNested).value)
res1: EitherT[List,String,String] = EitherT(List(Right(1), Right(2), Left(error), Left(error)))
  53. def toNestedValidated(implicit F: Functor[F]): Nested[F, [β$4$]Validated[A, β$4$], B]

    Transform this EitherT[F, A, B] into a Nested[F, Validated[A, ?], B].

    Transform this EitherT[F, A, B] into a Nested[F, Validated[A, ?], B].

    Example:

    scala> import cats.data.{EitherT, Validated}
scala> import cats.implicits._
scala> val f: Int => String = i => (i*2).toString
scala> val r1: EitherT[Option, String, Int => String] = EitherT.right(Some(f))
r1: cats.data.EitherT[Option,String,Int => String] = EitherT(Some(Right(<function1>)))
scala> val r2: EitherT[Option, String, Int] = EitherT.right(Some(10))
r2: cats.data.EitherT[Option,String,Int] = EitherT(Some(Right(10)))
scala> type ErrorOr[A] = Validated[String, A]
scala> (r1.toNestedValidated).ap(r2.toNestedValidated)
res0: cats.data.Nested[Option,ErrorOr,String] = Nested(Some(Valid(20)))
  54. def toNestedValidatedNec(implicit F: Functor[F]): Nested[F, [β$8$]Validated[Type[A], β$8$], B]

    Transform this EitherT[F, A, B] into a Nested[F, ValidatedNec[A, ?], B].

  55. def toNestedValidatedNel(implicit F: Functor[F]): Nested[F, [β$6$]Validated[NonEmptyList[A], β$6$], B]

    Transform this EitherT[F, A, B] into a Nested[F, ValidatedNel[A, ?], B].

  56. def toOption(implicit F: Functor[F]): OptionT[F, B]
  57. def toValidated(implicit F: Functor[F]): F[Validated[A, B]]
  58. def toValidatedNec(implicit F: Functor[F]): F[ValidatedNec[A, B]]
  59. def toValidatedNel(implicit F: Functor[F]): F[ValidatedNel[A, B]]
  60. def transform[C, D](f: (Either[A, B]) ⇒ Either[C, D])(implicit F: Functor[F]): EitherT[F, C, D]
  61. def traverse[G[_], D](f: (B) ⇒ G[D])(implicit traverseF: Traverse[F], applicativeG: Applicative[G]): G[EitherT[F, A, D]]
  62. val value: F[Either[A, B]]
  63. def valueOr[BB >: B](f: (A) ⇒ BB)(implicit F: Functor[F]): F[BB]
  64. def valueOrF[BB >: B](f: (A) ⇒ F[BB])(implicit F: Monad[F]): F[BB]
  65. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  66. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  67. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  68. def withValidated[AA, BB](f: (Validated[A, B]) ⇒ Validated[AA, BB])(implicit F: Functor[F]): EitherT[F, AA, BB]

    Run this value as a Validated against the function and convert it back to an EitherT.

    Run this value as a Validated against the function and convert it back to an EitherT.

    The Applicative instance for EitherT "fails fast" - it is often useful to "momentarily" have it accumulate errors instead, which is what the Validated data type gives us.

    Example:

    scala> import cats.implicits._
scala> type Error = String
scala> val v1: Validated[NonEmptyList[Error], Int] = Validated.invalidNel("error 1")
scala> val v2: Validated[NonEmptyList[Error], Int] = Validated.invalidNel("error 2")
scala> val eithert: EitherT[Option, Error, Int] = EitherT.leftT[Option, Int]("error 3")
scala> eithert.withValidated { v3 => (v1, v2, v3.toValidatedNel).mapN { case (i, j, k) => i + j + k } }
res0: EitherT[Option, NonEmptyList[Error], Int] = EitherT(Some(Left(NonEmptyList(error 1, error 2, error 3))))

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped