Xor

Represents a right-biased disjunction that is either an A or a B.

An instance of A Xor B is either a Left[A] or a Right[B].

A common use of Xor is to explicitly represent the possibility of failure in a result as opposed to throwing an exception. By convention, Left is used for errors and Right is reserved for successes. For example, a function that attempts to parse an integer from a string may have a return type of NumberFormatException Xor Int. However, since there is no need to actually throw an exception, the type (A) chosen for the "left" could be any type representing an error and has no need to actually extend Exception.

A Xor B is isomorphic to scala.Either[A, B], but Xor is right-biased, so methods such as map and flatMap apply only in the context of the "right" case. This right bias makes Xor more convenient to use than scala.Either in a monadic context. Methods such as swap, and leftMap provide functionality that scala.Either exposes through left projections.

Linear Supertypes

Serializable, Serializable, Product, Equals, AnyRef, Any

Known Subclasses

Left, Right

Abstract Value Members

abstract def canEqual(that: Any): Boolean

Definition Classes
Equals
abstract def productArity: Int

Definition Classes
Product
abstract def productElement(n: Int): Any

Definition Classes
Product

Concrete 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 ===[AA >: A, BB >: B](that: Xor[AA, BB])(implicit AA: Eq[AA], BB: Eq[BB]): Boolean
final def asInstanceOf[T0]: T0

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

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def combine[AA >: A, BB >: B](that: Xor[AA, BB])(implicit AA: Semigroup[AA], BB: Semigroup[BB]): Xor[AA, BB]
def compare[AA >: A, BB >: B](that: Xor[AA, BB])(implicit AA: Order[AA], BB: Order[BB]): Int
def ensure[AA >: A](onFailure: ⇒ AA)(f: (B) ⇒ Boolean): Xor[AA, B]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists(f: (B) ⇒ Boolean): Boolean
def finalize(): Unit

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

Definition Classes
AnyRef → Any
def getOrElse[BB >: B](default: ⇒ BB): BB
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isLeft: Boolean
def isRight: Boolean
def leftMap[C](f: (A) ⇒ C): Xor[C, B]
def map[D](f: (B) ⇒ D): Xor[A, D]
def merge[AA >: A](implicit ev: <:<[B, AA]): 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 orElse[C, BB >: B](fallback: ⇒ Xor[C, BB]): Xor[C, BB]
def partialCompare[AA >: A, BB >: B](that: Xor[AA, BB])(implicit AA: PartialOrder[AA], BB: PartialOrder[BB]): Double
def productIterator: Iterator[Any]

Definition Classes
Product
def productPrefix: String

Definition Classes
Product
def recover[BB >: B](pf: PartialFunction[A, BB]): Xor[A, BB]
def recoverWith[AA >: A, BB >: B](pf: PartialFunction[A, Xor[AA, BB]]): Xor[AA, BB]
def show[AA >: A, BB >: B](implicit AA: Show[AA], BB: Show[BB]): String
def swap: Xor[B, A]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def to[F[_], BB >: B](implicit monoidKF: MonoidK[F], applicativeF: Applicative[F]): F[BB]
def toEither: Either[A, B]
def toIor: Ior[A, B]
def toList: List[B]
def toOption: Option[B]
def toString(): String

Definition Classes
AnyRef → Any
def toValidated: Validated[A, B]
def toValidatedNel[AA >: A]: ValidatedNel[AA, B]

Returns a ValidatedNel representation of this disjunction with the Left value as a single element on the Invalid side of the NonEmptyList.
def traverse[F[_], AA >: A, D](f: (B) ⇒ F[D])(implicit F: Applicative[F]): F[Xor[AA, D]]
def valueOr[BB >: B](f: (A) ⇒ BB): BB
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]): Xor[AA, BB]

Related Docs: object Xor | package data

sealed abstract class Xor[+A, +B] extends Product with Serializable

Abstract Value Members

abstract def canEqual(that: Any): Boolean

abstract def productArity: Int

abstract def productElement(n: Int): Any

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ===[AA >: A, BB >: B](that: Xor[AA, BB])(implicit AA: Eq[AA], BB: Eq[BB]): Boolean

final def asInstanceOf[T0]: T0

def bimap[C, D](fa: (A) ⇒ C, fb: (B) ⇒ D): Xor[C, D]

def clone(): AnyRef

final def combine[AA >: A, BB >: B](that: Xor[AA, BB])(implicit AA: Semigroup[AA], BB: Semigroup[BB]): Xor[AA, BB]

def compare[AA >: A, BB >: B](that: Xor[AA, BB])(implicit AA: Order[AA], BB: Order[BB]): Int

def ensure[AA >: A](onFailure: ⇒ AA)(f: (B) ⇒ Boolean): Xor[AA, B]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(f: (B) ⇒ Boolean): Boolean

def finalize(): Unit

def flatMap[AA >: A, D](f: (B) ⇒ Xor[AA, D]): Xor[AA, D]

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

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

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

def forall(f: (B) ⇒ Boolean): Boolean

def foreach(f: (B) ⇒ Unit): Unit

final def getClass(): Class[_]

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

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isLeft: Boolean

def isRight: Boolean

def leftMap[C](f: (A) ⇒ C): Xor[C, B]

def map[D](f: (B) ⇒ D): Xor[A, D]

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orElse[C, BB >: B](fallback: ⇒ Xor[C, BB]): Xor[C, BB]

def partialCompare[AA >: A, BB >: B](that: Xor[AA, BB])(implicit AA: PartialOrder[AA], BB: PartialOrder[BB]): Double

def productIterator: Iterator[Any]

def productPrefix: String

def recover[BB >: B](pf: PartialFunction[A, BB]): Xor[A, BB]

def recoverWith[AA >: A, BB >: B](pf: PartialFunction[A, Xor[AA, BB]]): Xor[AA, BB]

def show[AA >: A, BB >: B](implicit AA: Show[AA], BB: Show[BB]): String

def swap: Xor[B, A]

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

def to[F[_], BB >: B](implicit monoidKF: MonoidK[F], applicativeF: Applicative[F]): F[BB]

def toEither: Either[A, B]

def toIor: Ior[A, B]

def toList: List[B]

def toOption: Option[B]

def toString(): String

def toValidated: Validated[A, B]

def toValidatedNel[AA >: A]: ValidatedNel[AA, B]

def traverse[F[_], AA >: A, D](f: (B) ⇒ F[D])(implicit F: Applicative[F]): F[Xor[AA, D]]

def valueOr[BB >: B](f: (A) ⇒ BB): BB

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]): Xor[AA, BB]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped