XorT

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

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

Linear Supertypes

Serializable, Serializable, Product, Equals, AnyRef, Any

Instance Constructors

new XorT(value: F[Xor[A, B]])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ===(that: XorT[F, A, B])(implicit eq: Eq[F[Xor[A, B]]]): Boolean
def applyAlt[D](ff: XorT[F, A, (B) ⇒ D])(implicit F: Apply[F]): XorT[F, A, D]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bimap[C, D](fa: (A) ⇒ C, fb: (B) ⇒ D)(implicit F: Functor[F]): XorT[F, C, D]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collectRight(implicit F: MonadCombine[F]): F[B]
def combine(that: XorT[F, A, B])(implicit F: Apply[F], A: Semigroup[A], B: Semigroup[B]): XorT[F, A, B]
def compare(that: XorT[F, A, B])(implicit o: Order[F[Xor[A, B]]]): Int
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def exists(f: (B) ⇒ Boolean)(implicit F: Functor[F]): F[Boolean]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap[AA >: A, D](f: (B) ⇒ XorT[F, AA, D])(implicit F: Monad[F]): XorT[F, AA, D]
def flatMapF[AA >: A, D](f: (B) ⇒ F[Xor[AA, D]])(implicit F: Monad[F]): XorT[F, AA, D]
def fold[C](fa: (A) ⇒ C, fb: (B) ⇒ C)(implicit F: Functor[F]): F[C]
def foldLeft[C](c: C)(f: (C, B) ⇒ C)(implicit F: Foldable[F]): C
def foldRight[C](lc: Eval[C])(f: (B, Eval[C]) ⇒ Eval[C])(implicit F: Foldable[F]): Eval[C]
def forall(f: (B) ⇒ Boolean)(implicit F: Functor[F]): F[Boolean]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getOrElse[BB >: B](default: ⇒ BB)(implicit F: Functor[F]): F[BB]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isLeft(implicit F: Functor[F]): F[Boolean]
def isRight(implicit F: Functor[F]): F[Boolean]
def leftMap[C](f: (A) ⇒ C)(implicit F: Functor[F]): XorT[F, C, B]
def map[D](f: (B) ⇒ D)(implicit F: Functor[F]): XorT[F, A, D]
def merge[AA >: A](implicit ev: <:<[B, AA], F: Functor[F]): F[AA]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def partialCompare(that: XorT[F, A, B])(implicit p: PartialOrder[F[Xor[A, B]]]): Double
def recover(pf: PartialFunction[A, B])(implicit F: Functor[F]): XorT[F, A, B]
def recoverWith(pf: PartialFunction[A, XorT[F, A, B]])(implicit F: Monad[F]): XorT[F, A, B]
def show(implicit show: Show[F[Xor[A, B]]]): String
def swap(implicit F: Functor[F]): XorT[F, B, A]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def to[G[_]](implicit functorF: Functor[F], monoidKG: MonoidK[G], applicativeG: Applicative[G]): F[G[B]]
def toEither(implicit F: Functor[F]): F[Either[A, B]]
def toOption(implicit F: Functor[F]): OptionT[F, B]
def toValidated(implicit F: Functor[F]): F[Validated[A, B]]
def traverse[G[_], D](f: (B) ⇒ G[D])(implicit traverseF: Traverse[F], traverseXorA: Traverse[[β]Xor[A, β]], applicativeG: Applicative[G]): G[XorT[F, A, D]]
val value: F[Xor[A, B]]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
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:
```
val v1: Validated[NonEmptyList[Error], Int] = ...
val v2: Validated[NonEmptyList[Error], Int] = ...
val xort: XorT[Error, Int] = ...

val result: XorT[NonEmptyList[Error], Int] =
  xort.withValidated { v3 => (v1 |@| v2 |@| v3.leftMap(NonEmptyList(_))) { case (i, j, k) => i + j + k } }
```

Related Docs: object XorT | package data

case class XorT[F[_], A, B](value: F[Xor[A, B]]) extends Product with Serializable

Instance Constructors

new XorT(value: F[Xor[A, B]])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ===(that: XorT[F, A, B])(implicit eq: Eq[F[Xor[A, B]]]): Boolean

def applyAlt[D](ff: XorT[F, A, (B) ⇒ D])(implicit F: Apply[F]): XorT[F, A, D]

final def asInstanceOf[T0]: T0

def bimap[C, D](fa: (A) ⇒ C, fb: (B) ⇒ D)(implicit F: Functor[F]): XorT[F, C, D]

def clone(): AnyRef

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

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

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

final def eq(arg0: AnyRef): Boolean

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

def finalize(): Unit

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

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

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

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

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

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

final def getClass(): Class[_]

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

final def isInstanceOf[T0]: Boolean

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

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

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

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

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

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

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

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

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

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

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

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

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

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

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped