Scala Yield 返回 Try[Either[]] 而不是 Either

Question

我正在尝试使用 Scala 基本操作进行一些动手编码，但陷入了以下示例代码中：

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

我收到的错误是它说

found Try[Either[Exception,Double]]

。

我不明白为什么它是 Try of Either 下的包装器。

PS - 这一定不是 Scala 中的完美方法，所以请随意发布您的示例代码。 :)

Answer 1

理解的关键是 for-compressions 可能会改变包装器内部的内容，但不会改变包装器本身。原因是因为对于

map

/

flatMap

的理解去糖调用了链第一步中确定的包装器。例如，考虑以下代码片段

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

请注意我们如何将

Try

包装器内的值从

41

转换为

42

，但包装器保持不变。或者，我们可以使用 for 理解来表达同样的事情

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

注意效果是完全一样的。现在考虑以下链接多个步骤的理解

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)

这扩展到

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

我们再次看到结果是相同的，即在包装器内部转换的值，但包装器保持不变。

最后考虑一下

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

原理保持不变 - 我们确实将

a + b

包裹在

Either

内，但这不会影响顶级外包装，它仍然是

Try

。

Answer 2

Mario Galic 的答案已经解释了您的代码的问题，但我会以不同的方式修复它。

两点：

1. Either[Exception, A]

   （或者更确切地说，

   Either[Throwable, A]

   ）相当于

   Try[A]

   ，其中

   Left

   扮演

   Failure

   的角色，

   Right

   扮演

   Success

   的角色。

2. 外部

   try

   /

   catch

   没有用，因为应该通过在

   Try

   中工作来捕获异常。

所以你可能想要类似的东西

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
}

有点不幸的是，如果你弄清楚理解的作用，这会毫无用处

map(q => q)

，所以你可以更直接地将其写为

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