Scala 3
3.9.0-RC1-bin-20260423-5d6b9a4-NIGHTLY
LearnInstallPlaygroundFind A LibraryCommunityBlog
LearnInstallPlaygroundFind A LibraryCommunityBlog
DocsAPI
Generated with
Copyright (c) 2002-2026, LAMP/EPFL
Copyright (c) 2002-2026, LAMP/EPFL
Scala 3/scala/scala.util/Left

Left

scala.util.Left
final case class Left[+A, +B](value: A) extends Either[A, B]

The left side of the disjoint union, as opposed to the scala.util.Right side.

Type parameters

A

the type of the value contained in this Left

B

the type of the Right alternative

Value parameters

value

the value wrapped in this Left

Attributes

Source
Either.scala
Graph
Supertypes
class Either[A, B]
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all

Members list

Value members

Concrete methods

def isLeft: Boolean

Returns true if this is a Left, false otherwise.

Returns true if this is a Left, false otherwise.

Left("tulip").isLeft // true
Right("venus fly-trap").isLeft // false

Attributes

Returns

true if this is a Left, false otherwise

Source
Either.scala
def isRight: Boolean

Returns true if this is a Right, false otherwise.

Returns true if this is a Right, false otherwise.

Left("tulip").isRight // false
Right("venus fly-trap").isRight // true

Attributes

Returns

true if this is a Right, false otherwise

Source
Either.scala
def withRight[B1 >: B]: Either[A, B1]

Upcasts this Left[A, B] to Either[A, B1]

Upcasts this Left[A, B] to Either[A, B1]

 Left(1)                   // Either[Int, Nothing]
 Left(1).withRight[String] // Either[Int, String]

Type parameters

B1

the target right type to widen to

Attributes

Source
Either.scala

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 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"

Type parameters

B1

the supertype of B used to widen the comparison type

Value parameters

elem

the element to test.

Attributes

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.

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

Value parameters

p

the predicate to apply to the Right value

Attributes

Returns

true if this is a Right and the predicate holds for its value

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.

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)

Type parameters

A1

the supertype of A used to widen the left type

Value parameters

p

the predicate to test the Right value against

zero

the value to use as Left if the predicate does not hold, evaluated lazily

Attributes

Returns

this Either if it is a Left or the predicate holds, otherwise Left(zero)

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.

Binds the given function across Right.

Type parameters

A1

the supertype of A used to widen the left type

B1

the right type of the resulting Either

Value parameters

f

the function to bind across Right

Attributes

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

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

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

Type parameters

A1

the supertype of A used to widen the left type

B1

the right type of the inner Either

Value parameters

ev

evidence that B is a subtype of Either[A1, B1]

Attributes

Returns

the inner Either if this is a Right, otherwise the outer 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.

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

Type parameters

C

the result type of the fold

Value parameters

fa

the function to apply to the Left value

fb

the function to apply to the Right value

Attributes

Returns

the result of applying fa or fb to the contained value

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.

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

Value parameters

f

the predicate to apply to the Right value

Attributes

Returns

true if this is a Left or the predicate holds for the Right value

Inherited from:
Either
Source
Either.scala
def foreach[U](f: B => U): Unit

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

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

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

Type parameters

U

the return type of the side-effecting function (discarded)

Value parameters

f

the side-effecting function to execute

Attributes

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.

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

Type parameters

B1

the supertype of B used to widen the return type

Value parameters

or

the default value to return if this is a Left, evaluated lazily

Attributes

Returns

the Right value if present, otherwise or

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

Joins an Either through Left.

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.

@tparam A1 the supertype of A constrained to be an Either[C, B1] @tparam B1 the supertype of B used to widen the right type @tparam C the left type of the inner Either @param ev evidence that A1 is a subtype of Either[C, B1] @return the inner Either if this is a Left, otherwise this Right value

Attributes

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

Joins an Either through Right.

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

@tparam A1 the supertype of A used to widen the left type @tparam B1 the supertype of B, evidenced to be an Either[A1, C] @tparam C the right type of the inner Either @param ev evidence that B1 is a subtype of Either[A1, C] @return the inner Either if this is a Right, otherwise this Left value

Attributes

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

Projects this Either as a Left.

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")

Attributes

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.

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)

Type parameters

B1

the result type of the mapping function

Value parameters

f

the function to apply to the Right value

Attributes

Returns

a new Either with the function applied if this is a Right, otherwise the unchanged Left

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.

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)

Type parameters

A1

the supertype of A used to widen the left type

B1

the supertype of B used to widen the right type

Value parameters

or

the alternative Either to return if this is a Left, evaluated lazily

Attributes

Returns

this Either if it is a Right, otherwise or

Inherited from:
Either
Source
Either.scala
def productElementNames: Iterator[String]

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

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

Attributes

Inherited from:
Product
Source
Product.scala
def productIterator: Iterator[Any]

An iterator over all the elements of this product.

An iterator over all the elements of this product.

Attributes

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.

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

Attributes

Returns

an Either with the left and right values swapped

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.

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

Attributes

Returns

a Some containing the Right value, or None if this is a Left

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.

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()

Attributes

Returns

a Seq containing the Right value, or an empty Seq if this is a Left

Inherited from:
Either
Source
Either.scala
def toTry(implicit ev: A <:< Throwable): Try[B]

Attributes

Inherited from:
Either
Source
Either.scala

Deprecated and Inherited methods

def right: RightProjection[A, B]

Projects this Either as a Right.

Projects this Either as a Right.

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

Attributes

Deprecated
[Since version 2.13.0] Either is now right-biased, use methods directly on Either
Inherited from:
Either
Source
Either.scala
Generated with
Copyright (c) 2002-2026, LAMP/EPFL
Copyright (c) 2002-2026, LAMP/EPFL