Scala Yeild returning Try[Either[]] rather then Either

Question

I am trying to do some handson with scala basic operations and got stuck here in the following sample code

  def insuranceRateQuote(a: Int, tickets:Int) : Either[Exception, Double] = {
    // ... something
    Right(Double)
  }

  def parseInsuranceQuoteFromWebForm(age: String, numOfTickets: String)  : Either[Exception, Double]= {
    try{
      val a = Try(age.toInt)
      val tickets = Try(numOfTickets.toInt)

      for{
        aa <- a
        t <- tickets
      } yield insuranceRateQuote(aa,t)        // ERROR HERE
    } catch {
      case _ => Left(new Exception)}
  }

The Error I am getting is that it says found Try[Either[Exception,Double]]

I am not getting why it is wrapper under Try of Either

PS - This must not be the perfect way to do in scala so feel free to post your sample code :)

It is quite weird to wrap a **Try** inside a `try`. – Luis Miguel Mejía Suárez Jun 24 '20 at 12:58 — Luis Miguel Mejía Suárez, Jun 24 '20 at 12:58

Mario Galic · Answer 1 · 2020-06-24T12:04:57.520

The key to understand is that for-comprehensions might transform what is inside the wrapper but will not change the wrapper itself. The reason is because for-comprehension de-sugar to map/flatMap calls on the wrapper determined in the first step of the chain. For example consider the following snippet

val result: Try[Int] = Try(41).map(v => v + 1)
// result: scala.util.Try[Int] = Success(42)

Note how we transformed the value inside the Try wrapper from 41 to 42 however the wrapper remained unchanged. Alternatively we could express the same thing using a for-comprehension

val result: Try[Int] = for { v <- Try(41) } yield v + 1
// result: scala.util.Try[Int] = Success(42)

Note how the effect is exactly the same. Now consider the following for comprehension which chains multiple steps

val result: Try[Int] =
  for {
    a <- Try(41)   // first step determines the wrapper for all the other steps
    b <- Try(1)
  } yield a + b
// result: scala.util.Try[Int] = Success(42)

This expands to

val result: Try[Int] =
  Try(41).flatMap { (a: Int) =>
    Try(1).map { (b: Int) => a + b }
  }
// result: scala.util.Try[Int] = Success(42)

where again we see the result is the same, namely, a value transformed inside the wrapper but wrapper remained untransformed.

Finally consider

val result: Try[Either[Exception, Int]] =
  for {
    a <- Try(41)       // first step still determines the top-level wrapper
    b <- Try(1)
  } yield Right(a + b) // here we wrap inside `Either`
// result: scala.util.Try[Either[Exception,Int]] = Success(Right(42))

The principle remains the same - we did wrap a + b inside Either however this does not affect the top-level outer wrapper which is still Try.

I updated my function definition as follows `def parseInsuranceQuoteFromWebForm(age: String, numOfTickets: String) : Try[Either[Exception, Double]]` Please let me know if this looks good or I can further modify with some scala stuff. Thanks! — Ani, Jun 24 '20 at 08:23
@Ani the best would be to transform the **Either** into a **Try** or _viceversa_, so you end up with just one kind of wrapper. Specially because a **Try** of an **Either** is hard to use and usually doesn't make sense. — Luis Miguel Mejía Suárez, Jun 24 '20 at 12:57

score 0 · Answer 2 · answered Jun 24 '20 at 13:03

Mario Galic's answer already explains the problem with your code, but I'd fix it differently.

Two points:

Either[Exception, A] (or rather, Either[Throwable, A]) is kind of equivalent to Try[A], with Left taking the role of Failure and Right the role of Success.
The outer try/catch is not useful because the exceptions should be captured by working in Try.

So you probably want something like

def insuranceRateQuote(a: Int, tickets:Int) : Try[Double] = {
  // ... something
  Success(someDouble)
}

def parseInsuranceQuoteFromWebForm(age: String, numOfTickets: String):  Try[Double] = {
  val a = Try(age.toInt)
  val tickets = Try(numOfTickets.toInt)

  for{
    aa <- a
    t <- tickets
    q <- insuranceRateQuote(aa,t)
  } yield q
}

A bit unfortunately, this does a useless map(q => q) if you figure out what the comprehension does, so you can write it more directly as

a.flatMap(aa => tickets.flatMap(t => insuranceRateQuote(aa,t)))

Scala Yeild returning Try[Either[]] rather then Either

2 Answers2