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

Answer 1

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 .

Answer 2

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

Two points:

1. 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 .

2. 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)))