Question

问题

我将从简化的解析问题开始。假设我有一个字符串列表，我想要解析成一个整数列表，并且我想积累错误。这在Scalaz 7中非常简单：

val lines = List("12", "13", "13a", "14", "foo")

def parseLines(lines: List[String]) = lines.traverseU(_.parseInt.toValidationNel)

我们可以确认它按预期工作：

scala> parseLines(lines).fold(_.foreach(t => println(t.getMessage)), println)
For input string: "13a"
For input string: "foo"

这很好，但是假设列表很长，我决定要捕获有关错误上下文的更多信息，以便更容易清理。为简单起见，我将在这里使用（零索引）行号来表示位置，但上下文也可以包含文件名或其他信息。

绕过位置

一种简单的方法是将位置传递给我的行解析器：

type Position = Int

case class InvalidLine(pos: Position, message: String) extends Throwable(
  f"At $pos%d: $message%s"
)

def parseLine(line: String, pos: Position) = line.parseInt.leftMap(
  _ => InvalidLine(pos, f"$line%s is not an integer!")
)

def parseLines(lines: List[String]) = lines.zipWithIndex.traverseU(
  (parseLine _).tupled andThen (_.toValidationNel)
)

这也有效：

scala> parseLines(lines).fold(_.foreach(t => println(t.getMessage)), println)
At 2: 13a is not an integer!
At 4: foo is not an integer!

但是在更复杂的情况下，像这样绕过这个位置会让人感到不快。

包装错误

另一种选择是包装行解析器产生的错误：

case class InvalidLine(pos: Position, underlying: Throwable) extends Throwable(
  f"At $pos%d: ${underlying.getMessage}%s",
  underlying
)

def parseLines(lines: List[String]) = lines.zipWithIndex.traverseU {
  case (line, pos) => line.parseInt.leftMap(InvalidLine(pos, _)).toValidationNel
}

再次，它运作得很好：

scala> parseLines(lines).fold(_.foreach(t => println(t.getMessage)), println)
At 2: For input string: "13a"
At 4: For input string: "foo"

但有时候我有一个很好的错误ADT，这种包装感觉不是特别优雅。

返回“部分”错误

第三种方法是让我的行解析器返回一个需要与一些附加信息（在本例中为位置）组合的部分错误。我会在这里使用Reader，但我们也可以将失败类型表示为Position => Throwable。我们可以重复使用上面的第一个（非包装）InvalidLine。

def parseLine(line: String) = line.parseInt.leftMap(
  error => Reader(InvalidLine((_: Position), error.getMessage))
)

def parseLines(lines: List[String]) = lines.zipWithIndex.traverseU {
  case (line, pos) => parseLine(line).leftMap(_.run(pos)).toValidationNel
}

这再次产生了所需的输出，但也感觉有点冗长和笨重。

问题

我一直遇到这种问题 - 我正在解析一些混乱的数据并希望得到很好的有用的错误消息，但我也不想通过我的所有解析逻辑来处理一堆位置信息。< / p>

是否有理由偏好上述方法之一？有更好的方法吗？

Answer 1

我将第一个和第二个选项与本地请求的无堆栈异常组合用于控制流。这是我发现的最好的事情，可以保持错误处理完全防弹，而且大部分都是不碍事。基本形式如下：

Ok.or[InvalidLine]{ bad =>
  if (somethingWentWrong) bad(InvalidLine(x))
  else y.parse(bad)  // Parsers should know about sending back info!
}

其中bad在调用时抛出异常，返回传递给它的数据，并且输出是类似自定义Either的类型。如果从外部作用域注入额外的上下文变得很重要，那么添加额外的变换器步骤就是添加上下文所需的全部内容：

Ok.or[Invalid].explain(i: InvalidLine => Invalid(i, myFile)) { bad =>
  // Parsing logic
}

实际上创建类来使这项工作比我想在这里发布的更加繁琐（特别是因为在我的所有实际工作代码中都有其他考虑因素模糊了细节），但这是逻辑。

哦，因为这最终只是一个类的应用方法，你总是可以

val validate = Ok.or[Invalid].explain(/* blah */)

validate { bad => parseA }
validate { bad => parseB }

以及所有常用的技巧。

（我认为bad的类型签名是bad: InvalidLine => Nothing并且apply的类型签名是(InvalidLine => Nothing) => T并不完全明显。）

Answer 2

过于简化的解决方案可能是：

import scala.util.{Try, Success, Failure}

def parseLines(lines: List[String]): List[Try[Int]] =
  lines map { l => Try (l.toInt) }

val lines = List("12", "13", "13a", "14", "foo")
println("LINES: " + lines)

val parsedLines = parseLines(lines)
println("PARSED: " + parsedLines)

val anyFailed: Boolean = parsedLines.exists(_.isFailure)
println("FAILURES EXIST?: " + anyFailed)

val failures: List[Throwable] = parsedLines.filter(_.isFailure).map{ case Failure(e) => e }
println("FAILURES: " + failures)

val parsedWithIndex = parsedLines.zipWithIndex
println("PARSED LINES WITH INDEX: " + parsedWithIndex)

val failuresWithIndex = parsedWithIndex.filter{ case (v, i) => v.isFailure }
println("FAILURES WITH INDEX: " + failuresWithIndex)

打印：

LINES: List(12, 13, 13a, 14, foo)

PARSED: List(Success(12), Success(13), Failure(java.lang.NumberFormatException: For input string: "13a"), Success(14), Failure(java.lang.NumberFormatException: For input string: "foo"))

FAILURES EXIST?: true

FAILURES: List(java.lang.NumberFormatException: For input string: "13a", java.lang.NumberFormatException: For input string: "foo")

PARSED LINES WITH INDEX: List((Success(12),0), (Success(13),1), (Failure(java.lang.NumberFormatException: For input string: "13a"),2), (Success(14),3), (Failure(java.lang.NumberFormatException: For input string: "foo"),4))

FAILURES WITH INDEX: List((Failure(java.lang.NumberFormatException: For input string: "13a"),2), (Failure(java.lang.NumberFormatException: For input string: "foo"),4))

鉴于你可以将所有这些包装在一个帮助器类中，抽象解析函数，概括输入和输出类型，甚至定义错误类型，无论它是异常还是别的。

我建议的是一种简单的基于地图的方法，可以根据任务定义确切的类型。

令人讨厌的是，您必须保留对parsedWithIndex的引用，以便能够获取索引和异常，除非您的异常将包含索引和其他上下文信息。

实施示例：

case class Transformer[From, To](input: List[From], f: From => To) {
  import scala.util.{Try, Success, Failure}

  lazy val transformedWithIndex: List[(Try[To], Int)] =
    input map { l => Try ( f(l) ) } zipWithIndex

  def failuresWithIndex =
    transformedWithIndex.filter { case (v, i) => v.isFailure }

  lazy val failuresExist: Boolean =
    ! failuresWithIndex.isEmpty

  def successfulOnly: List[To] =
    for {
      (e, _) <- transformedWithIndex
      value <- e.toOption
    } yield value
}

val lines = List("12", "13", "13a", "14", "foo")

val res = Transformer(lines, (l: String) => l.toInt)

println("FAILURES EXIST?: " + res.failuresExist)
println("PARSED LINES WITH INDEX: " + res.transformedWithIndex)
println("SUCCESSFUL ONLY: " + res.successfulOnly)

打印：

FAILURES EXIST?: true

PARSED LINES WITH INDEX: List((Success(12),0), (Success(13),1), (Failure(java.lang.NumberFormatException: For input string: "13a"),2), (Success(14),3), (Failure(java.lang.NumberFormatException: For input string: "foo"),4))

SUCCESSFUL ONLY: List(12, 13, 14)

Try可以替换为Either或您自己的自定义Failure。

这确实感觉面向对象而不是功能。

在验证错误中定位信息

问题

绕过位置

包装错误

返回“部分”错误

问题

2 个答案: