如何积累错误？

Question

假设我有几个case类和函数来测试它们：

case class PersonName(...)
case class Address(...)
case class Phone(...)

def testPersonName(pn: PersonName): Either[String, PersonName] = ...
def testAddress(a: Address): Either[String, Address] = ...
def testPhone(p: Phone): Either[String, Phone] = ...

现在我定义了一个新的case类< code>Person和一个测试函数，它很快就会失败。

case class Person(name: PersonName, address: Address, phone: Phone)

def testPerson(person: Person): Either[String, Person] = for {
  pn <- testPersonName(person.name).right
  a <- testAddress(person.address).right
  p <- testPhone(person.phone).right
} yield person;

现在，我希望函数testPerson累积错误，而不是快速失败。

我希望 testPerson 始终执行所有这些 test* 函数并返回 Either[List[String]， Person]。我该怎么做？

Answer 1

正如@TravisBrown告诉你的，因为理解并没有真正与错误累积混合在一起。事实上，当您不想要细粒度的错误控制时，通常会使用它们。

A for understanding将在发现第一个错误时“短路”自己，这几乎总是你想要的。

你做的不好的事情是使用< code>String来做异常的流控制。您应该始终使用< code >任一[Exception，Whatever]并通过< code > Scala . util . control . nostacktrace 和< code>scala.util.NonFatal微调日志记录。

有更好的选择，特别是：

scalaz.要么T和scalaz。验证内尔。

更新：（这是不完整的，我不知道你到底想要什么）。您有比匹配更好的选项，例如getOrElse和recover。

def testPerson(person: Person): Person = {
  val attempt = Try {
    val pn = testPersonName(person.name)
    val a = testAddress(person.address)
    testPhone(person.phone)
  }
  attempt match {
    case Success(person) => //..
    case Failure(exception) => //..
  }
}

Answer 2

Scala的＜code＞for＜/code＞理解（它是对＜code＞、flatMap＜/code＞和＜code＜map＞调用的组合）旨在允许您对一元计算进行排序，这样您就可以在后续步骤中访问早期计算的结果。考虑以下因素：

def parseInt(s: String) = try Right(s.toInt) catch {
  case _: Throwable => Left("Not an integer!")
}

def checkNonzero(i: Int) = if (i == 0) Left("Zero!") else Right(i)

def inverse(s: String): Either[String, Double] = for {
  i <- parseInt(s).right
  v <- checkNonzero(i).right
} yield 1.0 / v

这不会累积误差，事实上也没有合理的方法可以累积误差。假设我们调用< code>inverse("foo")。那么< code>parseInt显然会失败，这意味着我们无法为< code>i赋值，这意味着我们无法继续执行序列中的< code > check非零(i)步骤。

在您的情况下，您的计算没有这种依赖性，但您使用的抽象（一元排序）不知道这一点。您需要的是一个类似于＜code＞的类型，它不是一元的，但具有应用性。有关差异的详细信息，请参见我的回答。

例如，您可以使用Scalaz的验证编写以下内容，而无需更改任何单独的验证方法：

import scalaz._, syntax.apply._, syntax.std.either._

def testPerson(person: Person): Either[List[String], Person] = (
  testPersonName(person.name).validation.toValidationNel |@|
  testAddress(person.address).validation.toValidationNel |@|
  testPhone(person.phone).validation.toValidationNel
)(Person).leftMap(_.list).toEither

当然，这比必要的更冗长，并且会丢弃一些信息，并且在整个过程中使用验证会更干净一些。

Answer 3

您想隔离测试*方法并停止使用理解！

假设(不管出于什么原因)scalaz不适合你...这可以在不添加依赖性的情况下完成。

与许多scalaz示例不同，这是一个库不会比“常规”scala减少太多详细信息的示例：

def testPerson(person: Person): Either[List[String], Person] = {
  val name  = testPersonName(person.name)
  val addr  = testAddress(person.address)
  val phone = testPhone(person.phone)

  val errors = List(name, addr, phone) collect { case Left(err) => err }

  if(errors.isEmpty) Right(person) else Left(errors)      
}