Right

final case class Right[+A, +B](value: B) extends Either[A, B]

The right side of the disjoint union, as opposed to the scala.util.Left side.

class Either[A, B]
trait Product
trait Equals
class Object
trait Matchable
class Any

Value members

Concrete methods

def withLeft[A1 >: A]: Either[A1, B]

Upcasts this Right[A, B] to Either[A1, B]

Right("x") // Either[Nothing, String] Right("x").withLeft[Int] // Either[Int, String]

Inherited methods

final def contains[B1 >: B](elem: B1): Boolean

Returns true if this is a Right and its value is equal to elem (as determined by ==), returns false otherwise.

// Returns true because value of Right is "something" which equals "something". Right("something") contains "something" // Returns false because value of Right is "something" which does not equal "anything". Right("something") contains "anything" // Returns false because it's not a Right value. Left("something") contains "something"
Value Params
elem

the element to test.

Returns

true if this is a Right value equal to elem.

Inherited from
Either
Source
Either.scala
def exists(p: B => Boolean): Boolean

Returns false if Left or returns the result of the application of the given predicate to the Right value.

Right(12).exists(_ > 10) // true Right(7).exists(_ > 10) // false Left(12).exists(_ => true) // false
Inherited from
Either
Source
Either.scala
def filterOrElse[A1 >: A](p: B => Boolean, zero: => A1): Either[A1, B]

Returns Right with the existing value of Right if this is a Right and the given predicate p holds for the right value, or Left(zero) if this is a Right and the given predicate p does not hold for the right value, or Left with the existing value of Left if this is a Left.

Right(12).filterOrElse(_ > 10, -1) // Right(12) Right(7).filterOrElse(_ > 10, -1) // Left(-1) Left(7).filterOrElse(_ => false, -1) // Left(7)
Inherited from
Either
Source
Either.scala
def flatMap[A1 >: A, B1](f: B => Either[A1, B1]): Either[A1, B1]

Binds the given function across Right.

Value Params
f

The function to bind across Right.

Inherited from
Either
Source
Either.scala
def flatten[A1 >: A, B1](ev: B <:< Either[A1, B1]): Either[A1, B1]

Returns the right value if this is right or this value if this is left

Example

val l: Either[String, Either[String, Int]] = Left("pancake") val rl: Either[String, Either[String, Int]] = Right(Left("flounder")) val rr: Either[String, Either[String, Int]] = Right(Right(7)) l.flatten //Either[String, Int]: Left("pancake") rl.flatten //Either[String, Int]: Left("flounder") rr.flatten //Either[String, Int]: Right(7)

Equivalent to flatMap(id => id)

Inherited from
Either
Source
Either.scala
def fold[C](fa: A => C, fb: B => C): C

Applies fa if this is a Left or fb if this is a Right.

Value Params
fa

the function to apply if this is a Left

fb

the function to apply if this is a Right

Returns

the results of applying the function

Example

val result = util.Try("42".toInt).toEither result.fold( e => s"Operation failed with $e", v => s"Operation produced value: $v" )
Inherited from
Either
Source
Either.scala
def forall(f: B => Boolean): Boolean

Returns true if Left or returns the result of the application of the given predicate to the Right value.

Right(12).forall(_ > 10) // true Right(7).forall(_ > 10) // false Left(12).forall(_ => false) // true
Inherited from
Either
Source
Either.scala
def foreach[U](f: B => U): Unit

Executes the given side-effecting function if this is a Right.

Right(12).foreach(println) // prints "12" Left(12).foreach(println) // doesn't print
Value Params
f

The side-effecting function to execute.

Inherited from
Either
Source
Either.scala
def getOrElse[B1 >: B](or: => B1): B1

Returns the value from this Right or the given argument if this is a Left.

Right(12).getOrElse(17) // 12 Left(12).getOrElse(17) // 17
Inherited from
Either
Source
Either.scala
def joinLeft[A1 >: A, B1 >: B, C](ev: A1 <:< Either[C, B1]): Either[C, B1]

Joins an Either through Left.

This method requires that the left side of this Either is itself an Either type. That is, this must be some type like:

Either[Either[C, B], B]

(which respects the type parameter bounds, shown below.)

If this instance is a Left[Either[C, B]] then the contained Either[C, B] will be returned, otherwise this value will be returned unmodified.

Left[Either[Int, String], String](Right("flower")).joinLeft // Result: Right("flower") Left[Either[Int, String], String](Left(12)).joinLeft // Result: Left(12) Right[Either[Int, String], String]("daisy").joinLeft // Result: Right("daisy")

This method, and joinRight, are analogous to Option#flatten.

Inherited from
Either
Source
Either.scala
def joinRight[A1 >: A, B1 >: B, C](ev: B1 <:< Either[A1, C]): Either[A1, C]

Joins an Either through Right.

This method requires that the right side of this Either is itself an Either type. That is, this must be some type like:

Either[A, Either[A, C]]

(which respects the type parameter bounds, shown below.)

If this instance is a Right[Either[A, C]] then the contained Either[A, C] will be returned, otherwise this value will be returned unmodified.

Example

Right[String, Either[String, Int]](Right(12)).joinRight // Result: Right(12) Right[String, Either[String, Int]](Left("flower")).joinRight // Result: Left("flower") Left[String, Either[String, Int]]("flower").joinRight // Result: Left("flower")

This method, and joinLeft, are analogous to Option#flatten

Inherited from
Either
Source
Either.scala
def left: LeftProjection[A, B]

Projects this Either as a Left.

This allows for-comprehensions over the left side of Either instances, reversing Either's usual right-bias.

For example

for (s <- Left("flower").left) yield s.length // Left(6)

Continuing the analogy with scala.Option, a LeftProjection declares that Left should be analogous to Some in some code.

// using Option def interactWithDB(x: Query): Option[Result] = try Some(getResultFromDatabase(x)) catch { case _: SQLException => None } // this will only be executed if interactWithDB returns a Some val report = for (result <- interactWithDB(someQuery)) yield generateReport(result) report match { case Some(r) => send(r) case None => log("report not generated, not sure why...") } // using Either def interactWithDB(x: Query): Either[Exception, Result] = try Right(getResultFromDatabase(x)) catch { case e: SQLException => Left(e) } // run a report only if interactWithDB returns a Right val report = for (result <- interactWithDB(someQuery)) yield generateReport(result) report match { case Right(r) => send(r) case Left(e) => log(s"report not generated, reason was $e") } // only report errors for (e <- interactWithDB(someQuery).left) log(s"query failed, reason was $e")
Inherited from
Either
Source
Either.scala
def map[B1](f: B => B1): Either[A, B1]

The given function is applied if this is a Right.

Right(12).map(x => "flower") // Result: Right("flower") Left(12).map(x => "flower") // Result: Left(12)
Inherited from
Either
Source
Either.scala
def orElse[A1 >: A, B1 >: B](or: => Either[A1, B1]): Either[A1, B1]

Returns this Right or the given argument if this is a Left.

Right(1) orElse Left(2) // Right(1) Left(1) orElse Left(2) // Left(2) Left(1) orElse Left(2) orElse Right(3) // Right(3)
Inherited from
Either
Source
Either.scala

An iterator over the names of all the elements of this product.

Inherited from
Product
Source
Product.scala

An iterator over all the elements of this product.

Returns

in the default implementation, an Iterator[Any]

Inherited from
Product
Source
Product.scala
def swap: Either[B, A]

If this is a Left, then return the left value in Right or vice versa.

Example

val left: Either[String, Int] = Left("left") val right: Either[Int, String] = left.swap // Result: Right("left")

val right = Right(2) val left = Left(3) for { r1 <- right r2 <- left.swap } yield r1 * r2 // Right(6)
Inherited from
Either
Source
Either.scala
def toOption: Option[B]

Returns a Some containing the Right value if it exists or a None if this is a Left.

Right(12).toOption // Some(12) Left(12).toOption // None
Inherited from
Either
Source
Either.scala
def toSeq: Seq[B]

Returns a Seq containing the Right value if it exists or an empty Seq if this is a Left.

Right(12).toSeq // Seq(12) Left(12).toSeq // Seq()
Inherited from
Either
Source
Either.scala
def toTry(ev: A <:< Throwable): Try[B]
Inherited from
Either
Source
Either.scala

Deprecated and Inherited methods

@deprecated("Either is now right-biased, use methods directly on Either", "2.13.0")

Projects this Either as a Right.

Because Either is right-biased, this method is not normally needed.

Deprecated
Inherited from
Either
Source
Either.scala