Packages

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.

Source
EitherT.scala
Linear Supertypes
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 bimap[C, D](fa: (A) ⇒ C, fb: (B) ⇒ D)(implicit F: Functor[F]): EitherT[F, C, D]
  8. 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]]
  9. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  10. def collectRight(implicit FA: Alternative[F], FM: Monad[F]): F[B]
  11. 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)
  12. def compare(that: EitherT[F, A, B])(implicit o: Order[F[Either[A, B]]]): Int
  13. def ensure[AA >: A](onFailure: ⇒ AA)(f: (B) ⇒ Boolean)(implicit F: Functor[F]): EitherT[F, AA, B]
  14. def ensureOr[AA >: A](onFailure: (B) ⇒ AA)(f: (B) ⇒ Boolean)(implicit F: Functor[F]): EitherT[F, AA, B]
  15. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  16. def exists(f: (B) ⇒ Boolean)(implicit F: Functor[F]): F[Boolean]
  17. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  18. def flatMap[AA >: A, D](f: (B) ⇒ EitherT[F, AA, D])(implicit F: Monad[F]): EitherT[F, AA, D]
  19. def flatMapF[AA >: A, D](f: (B) ⇒ F[Either[AA, D]])(implicit F: Monad[F]): EitherT[F, AA, D]
  20. def fold[C](fa: (A) ⇒ C, fb: (B) ⇒ C)(implicit F: Functor[F]): F[C]
  21. def foldLeft[C](c: C)(f: (C, B) ⇒ C)(implicit F: Foldable[F]): C
  22. def foldRight[C](lc: Eval[C])(f: (B, Eval[C]) ⇒ Eval[C])(implicit F: Foldable[F]): Eval[C]
  23. def forall(f: (B) ⇒ Boolean)(implicit F: Functor[F]): F[Boolean]
  24. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  25. def getOrElse[BB >: B](default: ⇒ BB)(implicit F: Functor[F]): F[BB]
  26. def getOrElseF[BB >: B](default: ⇒ F[BB])(implicit F: Monad[F]): F[BB]
  27. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  28. def isLeft(implicit F: Functor[F]): F[Boolean]
  29. def isRight(implicit F: Functor[F]): F[Boolean]
  30. def leftFlatMap[BB >: B, D](f: (A) ⇒ EitherT[F, D, BB])(implicit F: Monad[F]): EitherT[F, D, BB]
  31. def leftMap[C](f: (A) ⇒ C)(implicit F: Functor[F]): EitherT[F, C, B]
  32. def leftSemiflatMap[D](f: (A) ⇒ F[D])(implicit F: Monad[F]): EitherT[F, D, B]
  33. def map[D](f: (B) ⇒ D)(implicit F: Functor[F]): EitherT[F, A, D]
  34. def mapK[G[_]](f: ~>[F, G]): EitherT[G, A, B]

    Modify the context F using transformation f.

  35. def merge[AA >: A](implicit ev: <:<[B, AA], F: Functor[F]): F[AA]
  36. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  37. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  38. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  39. def orElse[AA, BB >: B](default: ⇒ EitherT[F, AA, BB])(implicit F: Monad[F]): EitherT[F, AA, BB]
  40. def partialCompare(that: EitherT[F, A, B])(implicit p: PartialOrder[F[Either[A, B]]]): Double
  41. def recover(pf: PartialFunction[A, B])(implicit F: Functor[F]): EitherT[F, A, B]
  42. def recoverWith(pf: PartialFunction[A, EitherT[F, A, B]])(implicit F: Monad[F]): EitherT[F, A, B]
  43. def semiflatMap[D](f: (B) ⇒ F[D])(implicit F: Monad[F]): EitherT[F, A, D]
  44. def show(implicit show: Show[F[Either[A, B]]]): String
  45. def subflatMap[AA >: A, D](f: (B) ⇒ Either[AA, D])(implicit F: Functor[F]): EitherT[F, AA, D]
  46. def swap(implicit F: Functor[F]): EitherT[F, B, A]
  47. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  48. def to[G[_]](implicit F: Functor[F], G: Alternative[G]): F[G[B]]
  49. 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)))
  50. 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)))
  51. 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].

  52. def toOption(implicit F: Functor[F]): OptionT[F, B]
  53. def toValidated(implicit F: Functor[F]): F[Validated[A, B]]
  54. def toValidatedNel(implicit F: Functor[F]): F[ValidatedNel[A, B]]
  55. def transform[C, D](f: (Either[A, B]) ⇒ Either[C, D])(implicit F: Functor[F]): EitherT[F, C, D]
  56. def traverse[G[_], D](f: (B) ⇒ G[D])(implicit traverseF: Traverse[F], applicativeG: Applicative[G]): G[EitherT[F, A, D]]
  57. val value: F[Either[A, B]]
  58. def valueOr[BB >: B](f: (A) ⇒ BB)(implicit F: Functor[F]): F[BB]
  59. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  60. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  61. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  62. 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