19

假设我想编写一个具有以下签名的方法：

def parse(input: List[(String, String)]):
  ValidationNel[Throwable, List[(Int, Int)]]

对于输入中的每一对字符串，它需要验证两个成员都可以解析为整数，并且第一个小于第二个。然后它需要返回整数，累积出现的任何错误。

首先，我将定义一个错误类型：

import scalaz._, Scalaz._

case class InvalidSizes(x: Int, y: Int) extends Exception(
  s"Error: $x is not smaller than $y!"
)

现在我可以按如下方式实现我的方法：

def checkParses(p: (String, String)):
  ValidationNel[NumberFormatException, (Int, Int)] =
  p.bitraverse[
    ({ type L[x] = ValidationNel[NumberFormatException, x] })#L, Int, Int
  ](
    _.parseInt.toValidationNel,
    _.parseInt.toValidationNel
  )

def checkValues(p: (Int, Int)): Validation[InvalidSizes, (Int, Int)] =
  if (p._1 >= p._2) InvalidSizes(p._1, p._2).failure else p.success

def parse(input: List[(String, String)]):
  ValidationNel[Throwable, List[(Int, Int)]] = input.traverseU(p =>
    checkParses(p).fold(_.failure, checkValues _ andThen (_.toValidationNel))
  )

或者，或者：

def checkParses(p: (String, String)):
  NonEmptyList[NumberFormatException] \/ (Int, Int) =
  p.bitraverse[
    ({ type L[x] = ValidationNel[NumberFormatException, x] })#L, Int, Int
  ](
    _.parseInt.toValidationNel,
    _.parseInt.toValidationNel
  ).disjunction

def checkValues(p: (Int, Int)): InvalidSizes \/ (Int, Int) =
  (p._1 >= p._2) either InvalidSizes(p._1, p._2) or p

def parse(input: List[(String, String)]):
  ValidationNel[Throwable, List[(Int, Int)]] = input.traverseU(p =>
    checkParses(p).flatMap(s => checkValues(s).leftMap(_.wrapNel)).validation
  )

现在无论出于何种原因，第一个操作（验证对解析为字符串）对我来说就像一个验证问题，而第二个操作（检查值）感觉就像一个析取问题，感觉我需要组合这两个单子（这表明我应该使用\/，因为ValidationNel[Throwable, _]没有 monad 实例）。

在我的第一个实现中，我ValidationNel始终使用，然后fold在最后作为一种假flatMap. 第二，我根据是否需要错误累积或单子绑定在适当的情况下来ValidationNel回反弹。\/它们产生相同的结果。

我已经在实际代码中使用了这两种方法，但还没有形成对其中一种的偏好。我错过了什么吗？我应该更喜欢一个吗？

4

2 回答 2

10

这可能不是您正在寻找的答案，但我刚刚注意到Validation有以下方法

/** Run a disjunction function and back to validation again. Alias for `@\/` */
def disjunctioned[EE, AA](k: (E \/ A) => (EE \/ AA)): Validation[EE, AA] =
  k(disjunction).validation

/** Run a disjunction function and back to validation again. Alias for `disjunctioned` */
def @\/[EE, AA](k: (E \/ A) => (EE \/ AA)): Validation[EE, AA] =
  disjunctioned(k)

当我看到它们时，直到我想起这个问题，我才能真正看到它们的用处。它们允许您通过转换为析取来进行适当的绑定。

def checkParses(p: (String, String)):
  ValidationNel[NumberFormatException, (Int, Int)] =
  p.bitraverse[
    ({ type L[x] = ValidationNel[NumberFormatException, x] })#L, Int, Int
  ](
    _.parseInt.toValidationNel,
    _.parseInt.toValidationNel
  )

def checkValues(p: (Int, Int)): InvalidSizes \/ (Int, Int) =
  (p._1 >= p._2) either InvalidSizes(p._1, p._2) or p

def parse(input: List[(String, String)]):
  ValidationNel[Throwable, List[(Int, Int)]] = input.traverseU(p =>
    checkParses(p).@\/(_.flatMap(checkValues(_).leftMap(_.wrapNel)))
  )
于 2013-11-22T00:10:55.327 回答
2

以下是我的Cats代码的第二个版本的非常接近的翻译：

import scala.util.Try

case class InvalidSizes(x: Int, y: Int) extends Exception(
  s"Error: $x is not smaller than $y!"
)

def parseInt(input: String): Either[Throwable, Int] = Try(input.toInt).toEither

def checkValues(p: (Int, Int)): Either[InvalidSizes, (Int, Int)] =
  if (p._1 >= p._2) Left(InvalidSizes(p._1, p._2)) else Right(p)

import cats.data.{EitherNel, ValidatedNel}
import cats.instances.either._
import cats.instances.list._
import cats.syntax.apply._
import cats.syntax.either._
import cats.syntax.traverse._

def checkParses(p: (String, String)): EitherNel[Throwable, (Int, Int)] =
  (parseInt(p._1).toValidatedNel, parseInt(p._2).toValidatedNel).tupled.toEither

def parse(input: List[(String, String)]): ValidatedNel[Throwable, List[(Int, Int)]] =
  input.traverse(fields =>
    checkParses(fields).flatMap(s => checkValues(s).toEitherNel).toValidated
  )

为了更新这个问题，这段代码“根据我是否需要错误累积或单子绑定在适当的情况下来ValidatedNel回弹跳”。Either

自从我提出这个问题以来的近六年里，Cats引入了一个Parallel类型类（在Cats 2.0.0中得到了改进），它正好解决了我遇到的问题：

import cats.data.EitherNel
import cats.instances.either._
import cats.instances.list._
import cats.instances.parallel._
import cats.syntax.either._
import cats.syntax.parallel._

def checkParses(p: (String, String)): EitherNel[Throwable, (Int, Int)] =
  (parseInt(p._1).toEitherNel, parseInt(p._2).toEitherNel).parTupled

def parse(input: List[(String, String)]): EitherNel[Throwable, List[(Int, Int)]] =
  input.parTraverse(fields =>
    checkParses(fields).flatMap(checkValues(_).toEitherNel)
  )

当我们想要累积错误时，我们可以切换par应用运算符的版本，traverse否则我们正在工作，这给了我们一元绑定，我们不再需要引用。tupledEitherValidated

于 2019-09-11T06:59:21.433 回答