Scala Any card on the right or left.

Question

Is it possible to handle Either same way as Option ? In Option , I have a getOrElse function, in Either I want to return Left or the Right process. I am looking for the fastest way to do this without any patterns like:

 val myEither:Either[String, Object] = Right(new Object()) myEither match { case Left(leftValue) => value case Right(righValue) => "Success" } 

Answer 1

In Scala 2.12,

Or the right offset, which means that Right is considered standard for the job. If it's left, operations like map, flatMap, ... return Left without any changes

so you can do

 myEither.map(_ => "Success").merge 

if you find it more readable than fold .

Answer 2

Both cchantep and Marth are good solutions to your immediate problem. But in a broader sense, it is difficult to consider it as something completely analogous to Option , in particular, allowing you to express sequences of potentially unsuccessful calculations for understanding. It either has a projection API (used in the cchantep solution), but it is a bit broken. (Either projections are built for understanding with protection, pattern matching, or variable assignment.)

FWIW, I wrote a library to solve this problem. It increases either this API . You define bias for your Aithers. “Right offset” means that a regular stream (map, get, etc.) is represented by a Right object, and Left objects are some kind of problem. (The right offset is normal, although you can also define the left offset if you want). Then you can consider Either as Option ; it disables a completely similar API.

 import com.mchange.leftright.BiasedEither import BiasedEither.RightBias._ val myEither:Either[String, Object] = ... val o = myEither.getOrElse( "Substitute" ) 

More useful, now you can treat either as a real scala monad, i.e. use flatMap, map, filter and for understanding:

 val myEither : Either[String, Point] = ??? val nextEither = myEither.map( _.x ) // Either[String,Int] 

or

 val myEither : Either[String, Point] = ??? def findGalaxyAtPoint( p : Point ) : Either[String,Galaxy] = ??? val locPopPair : Either[String, (Point, Long)] = { for { p <- myEither g <- findGalaxyAtPoint( p ) } yield { (p, g.population) } } 

If all processing steps are successful, locPopPair will be Right[Long] . If something went wrong, this will be the first Left[String] encountered.

This is a little trickier, but it's nice to define an empty token. Let's look at a small change for understanding above:

 val locPopPair : Either[String, (Point, Long)] = { for { p <- myEither g <- findGalaxyAtPoint( p ) if px > 1000 } yield { (p, g.population) } } 

What happens if the px > 1000 test fails? We want to return some Left , which means "empty", but a universal suitable value (not all Left are Left[String] ). At this point, what happens, the code will throw a NoSuchElementException but we can specify an empty token ourselves, as shown below:

 import com.mchange.leftright.BiasedEither val RightBias = BiasedEither.RightBias.withEmptyToken[String]("EMPTY") import RightBias._ val myEither : Either[String, Point] = ??? def findGalaxyAtPoint( p : Point ) : Either[String,Galaxy] = ??? val locPopPair : Either[String, (Point, Long)] = { for { p <- myEither g <- findGalaxyAtPoint( p ) if px > 1000 } yield { (p, g.population) } } 

Now, if the px > 1000 test fails, there will be no exceptions, locPopPair will just be Left("EMPTY") .

Answer 3

You can use .fold :

 scala> val r: Either[Int, String] = Right("hello") r: Either[Int,String] = Right(hello) scala> r.fold(_ => "got a left", _ => "Success") res7: String = Success scala> val l: Either[Int, String] = Left(1) l: Either[Int,String] = Left(1) scala> l.fold(_ => "got a left", _ => "Success") res8: String = got a left 

---

Edit:

Repeating your question, I don’t understand if you want to return the value to Left or another (defined elsewhere)
If this is the first, you can pass identity to .fold , however this can change the return type to Any :

 scala> r.fold(identity, _ => "Success") res9: Any = Success 

Answer 4

I think you can do the following.

 def foo(myEither: Either[String, Object]) = myEither.right.map(rightValue => "Success")