Scalaz使用ValidationNel缓慢失败

Question

我正在学习Scala，今天我遇到了使用Fail Slow的Scalaz ValidationNel机制，但是很难理解如何使用它。我正在阅读这些博客：Blog1，我也在阅读StackOverflow的文章：StackOverflow，但是对于非功能程序员来说，这真的很难理解。有人能提供一个简单的例子来说明如何在Scala中积累ValidationNel中的错误吗？有一个关于这个例子的描述也是非常有帮助的。

Answer 1

使用您所链接的博客中的示例

val sumV: ValidationNEL[String, Int] = for {
  a <- 42.successNel[String]
  b <- "Boo".failNel[Int]
  c <- "Wah wah".failNel[Int] // by defn of flatMap, can't get here
} yield a + b + c

这样做的目的是使用flatMap将各种操作链接在一起。42.例如，连续.failNelInt创造了成功，而"Boo".failNelInt则创建了一个失败。flatMap在这里的工作方式是，只有在成功的情况下才能继续执行下一个操作。因此，这是一个“快速失败”操作--它将第一个故障收集到错误案例中并停止。

如果你想“慢慢来”。收集所有可能的失败，您需要使用不同的方法。这就是应用程序进来的地方。

val yes = 3.14.successNel[String]
val doh = "Error".failNel[Double]

def addTwo(x: Double, y: Double) = x + y

(yes |@| yes)(addTwo) // Success(6.28)
(doh |@| doh)(addTwo) // Failure(NonEmptyList(Error, Error))

(a |@| b)(someFunctionOfTwoArgsHere) --这意味着“执行'a‘操作，执行'b’操作，如果两者都成功，则执行someFunctionOfTwoArgsHere(a，b)。否则，接受任何失败并组合它们。因此，如果a失败，但b成功，您将得到验证失败和失败的结果。如果a和b失败，您将得到验证失败，结果是a和b失败。

Answer 2

前面的答案是好的，但我知道您来自OOP范式，所以让我举另一个例子来比较这两种范式。

共同代码：

val a = "1"
val b = "aaa"
val c = "bbb"

def isAllDigits(x: String) = x forall Character.isDigit
def appendError(x: String, errors: mutable.Buffer[String]) = errors += s"$x is not number"

type Errors = NonEmptyList[String]

// disjunction \/ for fail fast
def toDigitFailFast(x: String): Errors \/ Int = {
  if (isAllDigits(x)) {
    x.toInt.right
  } else {
    s"$x is not number".wrapNel.left
  }
}

// validation nel (non empty list) for fail slow
def toDigitFS(x: String): ValidationNel[String, Int] = {
  if (x forall Character.isDigit) {
    x.toInt.successNel
  } else {
    s"$x is not number".failureNel
  }
}

失败快速命令式代码：

// fail fast imperative programming
println("---\nFail Fast imperative")
val failFastErrors = mutable.Buffer.empty[String]

if(isAllDigits(a)) {
  if(isAllDigits(b)) {
    if(isAllDigits(c)) {
      val total = a.toInt + b.toInt + c.toInt
      println(s"Total = ${total}!!")
    } else {
      appendError(c, failFastErrors)
    }
  } else {
    appendError(b, failFastErrors)
  }
} else {
  appendError(a, failFastErrors)
}

if(failFastErrors.nonEmpty) {
  println("Errors:")
  for(error <- failFastErrors) {
    println(error)
  }
}

故障快速功能代码(带析取/)：

val resultFunc = for {
  x <- toDigitFailFast(a)
  y <- toDigitFailFast(b)
  z <- toDigitFailFast(c)
} yield (x + y + z)

resultFunc match {
  case \/-(total) => println(s"Total = $total")
  case -\/(errors) =>
    println("Errors:")
    errors.foreach(println)
}

first输出(只告诉您第一个错误)：

Fail Fast imperative
Errors:
aaa is not number
Fail Fast functional
Errors:
aaa is not number

现在，用于命令式的失败慢速代码：

// fail slow imperative programming
println("---\nFail Slow imperative")
val failSlowErrors = mutable.Buffer.empty[String]

if(!isAllDigits(a)) {
  appendError(a, failSlowErrors)
}
if(!isAllDigits(b)) {
  appendError(b, failSlowErrors)
}
if(!isAllDigits(c)) {
  appendError(c, failSlowErrors)
}

if(failSlowErrors.isEmpty) {
  val total = a.toInt + b.toInt + c.toInt
  println(s"Total = ${total}!!")
} else {
  println("Errors:")
  for(error <- failSlowErrors) {
    println(error)
  }
}

功能版本(fail )：

// fail slow functional programming
println("---\nFail Slow functional")


val resultFuncSlow = 
  (toDigitFS(a) |@| toDigitFS(b) |@| toDigitFS(c)) { _ + _ + _ }

resultFuncSlow match {
  case Success(result) => println(result)
  case Failure(errors) =>
    println("Errors:")
    errors.foreach(println)
}

以及两个错误的输出：

Fail Slow imperative
Errors:
aaa is not number
bbb is not number
---
Fail Slow functional
Errors:
aaa is not number
bbb is not number