XorT

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: XorT[F, A, B])(implicit eq: Eq[F[Xor[A, B]]]): Boolean

   

5. def applyAlt[D](ff: XorT[F, A, (B) ⇒ D])(implicit F: Apply[F]): XorT[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]): XorT[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[XorT[F, C, D]]

   

9. def clone(): AnyRef

   

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( ... )

10. def collectRight(implicit F: MonadCombine[F]): F[B]

    

11. def combine(that: XorT[F, A, B])(implicit F: Apply[F], B: Semigroup[B]): XorT[F, A, B]

    

    Similar to Xor.combine but mapped over an F context.

    Similar to Xor.combine but mapped over an F context.

    Examples:

    scala> import cats.data.XorT
    scala> import cats.implicits._
    scala> val l1: XorT[Option, String, Int] = XorT.left(Some("error 1"))
    scala> val l2: XorT[Option, String, Int] = XorT.left(Some("error 2"))
    scala> val r3: XorT[Option, String, Int] = XorT.right(Some(3))
    scala> val r4: XorT[Option, String, Int] = XorT.right(Some(4))
    scala> val noneXorT: XorT[Option, String, Int] = XorT.left(None)
    
    scala> l1 combine l2
    res0: XorT[Option, String, Int] = XorT(Some(Left(error 1)))
    
    scala> l1 combine r3
    res1: XorT[Option, String, Int] = XorT(Some(Left(error 1)))
    
    scala> r3 combine l1
    res2: XorT[Option, String, Int] = XorT(Some(Left(error 1)))
    
    scala> r3 combine r4
    res3: XorT[Option, String, Int] = XorT(Some(Right(7)))
    
    scala> l1 combine noneXorT
    res4: XorT[Option, String, Int] = XorT(None)
    
    scala> noneXorT combine l1
    res5: XorT[Option, String, Int] = XorT(None)
    
    scala> r3 combine noneXorT
    res6: XorT[Option, String, Int] = XorT(None)
    
    scala> noneXorT combine r4
    res7: XorT[Option, String, Int] = XorT(None)

12. def compare(that: XorT[F, A, B])(implicit o: Order[F[Xor[A, B]]]): Int

    

13. def ensure[AA >: A](onFailure: ⇒ AA)(f: (B) ⇒ Boolean)(implicit F: Functor[F]): XorT[F, AA, B]

    

14. final def eq(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

15. def exists(f: (B) ⇒ Boolean)(implicit F: Functor[F]): F[Boolean]

    

16. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

17. def flatMap[AA >: A, D](f: (B) ⇒ XorT[F, AA, D])(implicit F: Monad[F]): XorT[F, AA, D]

    

18. def flatMapF[AA >: A, D](f: (B) ⇒ F[Xor[AA, D]])(implicit F: Monad[F]): XorT[F, AA, D]

    

19. def fold[C](fa: (A) ⇒ C, fb: (B) ⇒ C)(implicit F: Functor[F]): F[C]

    

20. def foldLeft[C](c: C)(f: (C, B) ⇒ C)(implicit F: Foldable[F]): C

    

21. def foldRight[C](lc: Eval[C])(f: (B, Eval[C]) ⇒ Eval[C])(implicit F: Foldable[F]): Eval[C]

    

22. def forall(f: (B) ⇒ Boolean)(implicit F: Functor[F]): F[Boolean]

    

23. final def getClass(): Class[_]

    

    Definition Classes

    AnyRef → Any

24. def getOrElse[BB >: B](default: ⇒ BB)(implicit F: Functor[F]): F[BB]

    

25. def getOrElseF[BB >: B](default: ⇒ F[BB])(implicit F: Monad[F]): F[BB]

    

26. final def isInstanceOf[T0]: Boolean

    

    Definition Classes

    Any

27. def isLeft(implicit F: Functor[F]): F[Boolean]

    

28. def isRight(implicit F: Functor[F]): F[Boolean]

    

29. def leftMap[C](f: (A) ⇒ C)(implicit F: Functor[F]): XorT[F, C, B]

    

30. def map[D](f: (B) ⇒ D)(implicit F: Functor[F]): XorT[F, A, D]

    

31. def merge[AA >: A](implicit ev: <:<[B, AA], F: Functor[F]): F[AA]

    

32. final def ne(arg0: AnyRef): Boolean

    

    Definition Classes

    AnyRef

33. final def notify(): Unit

    

    Definition Classes

    AnyRef

34. final def notifyAll(): Unit

    

    Definition Classes

    AnyRef

35. def orElse[AA, BB >: B](default: ⇒ XorT[F, AA, BB])(implicit F: Monad[F]): XorT[F, AA, BB]

    

36. def partialCompare(that: XorT[F, A, B])(implicit p: PartialOrder[F[Xor[A, B]]]): Double

    

37. def recover(pf: PartialFunction[A, B])(implicit F: Functor[F]): XorT[F, A, B]

    

38. def recoverWith(pf: PartialFunction[A, XorT[F, A, B]])(implicit F: Monad[F]): XorT[F, A, B]

    

39. def show(implicit show: Show[F[Xor[A, B]]]): String

    

40. def subflatMap[AA >: A, D](f: (B) ⇒ Xor[AA, D])(implicit F: Functor[F]): XorT[F, AA, D]

    

41. def swap(implicit F: Functor[F]): XorT[F, B, A]

    

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

    

    Definition Classes

    AnyRef

43. def to[G[_]](implicit functorF: Functor[F], monoidKG: MonoidK[G], applicativeG: Applicative[G]): F[G[B]]

    

44. def toEither(implicit F: Functor[F]): F[Either[A, B]]

    

45. def toOption(implicit F: Functor[F]): OptionT[F, B]

    

46. def toValidated(implicit F: Functor[F]): F[Validated[A, B]]

    

47. def transform[C, D](f: (Xor[A, B]) ⇒ Xor[C, D])(implicit F: Functor[F]): XorT[F, C, D]

    

48. def traverse[G[_], D](f: (B) ⇒ G[D])(implicit traverseF: Traverse[F], applicativeG: Applicative[G]): G[XorT[F, A, D]]

    

49. val value: F[Xor[A, B]]

    

50. def valueOr[BB >: B](f: (A) ⇒ BB)(implicit F: Functor[F]): F[BB]

    

51. final def wait(): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

53. final def wait(arg0: Long): Unit

    

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

54. def withValidated[AA, BB](f: (Validated[A, B]) ⇒ Validated[AA, BB])(implicit F: Functor[F]): XorT[F, AA, BB]

    

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

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

    The Applicative instance for XorT "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.std.option._
    scala> import cats.std.list._
    scala> import cats.syntax.cartesian._
    scala> type Error = String
    scala> val v1: Validated[NonEmptyList[Error], Int] = Validated.Invalid(NonEmptyList("error 1"))
    scala> val v2: Validated[NonEmptyList[Error], Int] = Validated.Invalid(NonEmptyList("error 2"))
    scala> val xort: XorT[Option, Error, Int] = XorT(Some(Xor.left("error 3")))
    scala> xort.withValidated { v3 => (v1 |@| v2 |@| v3.leftMap(NonEmptyList(_))).map{ case (i, j, k) => i + j + k } }
    res0: XorT[Option, NonEmptyList[Error], Int] = XorT(Some(Left(OneAnd(error 1,List(error 2, error 3)))))