scala - 我如何（最好）将选项转换为尝试？

Question

我如何（最好）将方法调用返回的 Option 转换为 Try （根据偏好，尽管 Either 或 scalaz\/甚至 Validation 可能都可以），包括在适当的情况下指定 Failure 值？

例如，我有以下代码，感觉很笨拙，但至少可以完成（大部分）工作：

import scala.util._

case class ARef(value: String)
case class BRef(value: String)
case class A(ref: ARef, bRef: BRef)
class MismatchException(msg: String) extends RuntimeException(msg)

trait MyTry {

  // Given:
  val validBRefs: List[BRef]

  // Want to go from an Option[A] (obtained, eg., via a function call passing a provided ARef)
  // to a Try[BRef], where the b-ref needs to be checked against the above list of BRefs or fail:

  def getValidBRefForReferencedA(aRef: ARef): Try[BRef] = {

    val abRef = for {
      a <- get[A](aRef) // Some function that returns an Option[A]
      abRef = a.bRef
      _ <- validBRefs.find(_ == abRef)
    } yield (abRef)

    abRef match {
      case Some(bRef) => Success(bRef)
      case None => Failure(new MismatchException("No B found matching A's B-ref"))
    }
  }
}

感觉应该有一种方法可以将最终匹配变形为 map 或 flatMap 或类似的构造，并合并到前面的理解中。

此外，如果与 BRef 检查失败相比，从 ARef 返回 Option[A] 的调用失败（返回 None），我希望能够指定不同的失败消息（我只关心知道失败的一个原因，因此 scalaz Validation 感觉并不理想）。

这是使用单子变压器的合适地方吗？如果是这样，scalaz 是否提供合适的，或者有人可以举例说明它的外观吗？

score 16 · Accepted Answer

您可以使用隐式转换

  implicit class OptionOps[A](opt: Option[A]) {

    def toTry(msg: String): Try[A] = {
      opt
        .map(Success(_))
        .getOrElse(Failure(new NoSuchElementException(msg)))
    }
  }

Scala 标准库使用这种方法。请参阅http://docs.scala-lang.org/tutorials/FAQ/finding-implicits.html#companion-objects-of-a-type

score 10 · Accepted Answer

简短而简单

Try(option.get)

不需要花哨的映射。如果选项为空，您会收到如下错误：

java.util.NoSuchElementException: None.get

score 8 · Accepted Answer

如果您从一开始就使用Tryfor-comp，那么您可以在最后消除比赛。您可以通过强制Option到Tryvia来做到这一点fold。这可能是这样的：

def getValidBRefForReferencedA(aRef: ARef): Try[BRef] = {
  for {
    a <- get[A](aRef).fold[Try[A]](Failure[A](new OtherException("Invalid aRef supplied")))(Success(_))
    abRef = a.bRef
    _ <- validBRefs.find(_ == abRef).fold[Try[BRef]](Failure(new MismatchException("No B found matching A's B-ref")))(Success(_))
  } yield abRef
}

使用这种方法，您可以获得两个不同检查的不同异常。它并不完美，但也许它对你有用。

score 8 · Accepted Answer

myOption
  .toRight(new Exception("y"))
  .toTry

此代码将返回 a Success(x)if myOptionisSome(x)或Failure(Exception("y"))if it is a None。

score 2 · Accepted Answer

如果你想使用一个Either，你可以使用Option.toRight：

def getValidBRefForReferencedA(aRef: ARef): Either[Throwable,BRef] = {    
  for {
    a <- get[A](aRef).toRight[Throwable](new Exception("Invalid ARef")).right
    bRef <- validBRefs.find(_ == a.bRef).toRight(new MismatchException("No B found matching A's B-ref")).right
  } yield bRef
}

使用 a Try，您可以简单地以非常程序化的方式编写代码，通过在需要的地方抛出适当的异常并用包装整个代码 Try.apply（这将捕获异常并将它们作为Failure实例呈现）。

def getValidBRefForReferencedA(aRef: ARef): Try[BRef] = Try {
  val a = get[A](aRef).getOrElse(throw new Exception("Invalid ARef"))
  validBRefs.find(_ == a.bRef).getOrElse(throw new MismatchException("No B found matching A's B-ref"))
}

score 1 · Accepted Answer

[编辑以识别不同的故障]

试图简化

def getValidBRefForReferencedA(aRef: ARef): Try[BRef] = {
  val abRef = for {
    a <- get[A](aRef)
    bRef = a.bRef
    result = Either.cond(validBRefs.contains(bRef), bRef, "Invalid B Reference")
  } yield result

  abRef.map {
    case Right(bRef) => Success(bRef)
    case Left(error) => Failure(new InvalidReferenceException(error))
  }.getOrElse(Failure(new MismatchException("No B found matching A's B-ref")))
}

score -1 · Accepted Answer

我已经制定了一个替代解决方案，尽管它仍然不允许我为 Option[A] 为 None 而 BRef 无效的情况指定不同的失败消息：

def getValidBRefForReferencedA(aRef: ARef): Try[BRef] = 
  Try {
    (for {
      a <- get[A](aRef)
      bRef = a.bRef
      _ <- bs.find(_ == bRef)
    } yield (bRef)) getOrElse (throw new MismatchException("No B found matching A's B-ref"))
  }

我想我希望应该有一种方法可以快速将返回的 Option[A] 转换为 Try （以适当的惯用 Scala 方式 - 例如在 for-comprehension 中），然后继续处理（获取和检查b-ref) 同时设置任何适当的失败。

scala - 我如何（最好）将选项转换为尝试？

7 回答 7

简短而简单

Related

Reference