在 Scala 中使用一系列按名称参数进行验证? [英] Validation with a sequence of by-name parameters in Scala?

问题描述

我想对所有返回 Either[Error,Item] 的操作序列进行验证它应该是快速失败的(在我最初的需要中)，我的意思是，返回任一 [Error,Seq[Item]].如果出现错误，很明显我不希望执行以下操作.但将来我可能想收集所有错误，而不是只返回第一个.

I'd like to implement validation for a sequence of operations that all return Either[Error,Item] It should be fail-fast (in my initial need), I mean, returning Either[Error,Seq[Item]]. If there is an error, it's obvious i do not want the following operations to be performed. But in the future i may want to collect all the errors instead of returning only the first one.

我知道 Scalaz 可以完成这项工作，但现在我完全不了解 Scalaz 的所有部分，而且我很确定有一种更简单的方法可以在不使用 Scalaz 的情况下完成它，但例如使用按名称参数.

I know Scalaz can do the job but for now I quite don't understand all parts of Scalaz and I'm pretty sure there's a simpler way to do it without using Scalaz, but using by-name parameters for exemple.

有没有办法按名称存储序列中的参数?这样我就可以创建一系列代表我的操作的按名称值?

Is there a way to store by-name parameters in a sequence? So that i can create a sequence of by-name values that represent my operations?

我的意思是，某种类型 Seq[=>;要么[错误，项目]]然后我可以做一些事情，比如调用 takeWhile 或 collectFirst 或类似的东西，而无需在创建序列之前执行所有操作?我希望这些操作仅在对序列进行迭代时执行.

I mean, some kind of type Seq[=> Either[Error,Item]] Then I could do something like calling takeWhile or collectFirst or something somilar, without all the operations being performed before the creation of the sequence? I would expect the operations to be performed only when iterating on the sequence.

谢谢

推荐答案

你确实可以使用 Seq[() =>要么[Error, Item]] 在集合创建时推迟计算.所以例如

You can indeed use a Seq[() => Either[Error, Item]] to defer the computation at collection creation time. So for example

val doSomething1: () => Either[Error, Item] = () => { println(1); Right(1) }
val doSomething2: () => Either[Error, Item] = () => { println(2); Right(2) }
val doSomething3: () => Either[Error, Item] = () => { println(3); Left("error") }
val doSomething4: () => Either[Error, Item] = () => { println(4); Right(3) }
val doSomething5: () => Either[Error, Item] = () => { println(5); Left("second error") }
val l = Seq(doSomething1, doSomething2, doSomething3, doSomething4, doSomething5)

(Items 是示例中的 Ints 和 Errors 是 Strings)

(Items are Ints in the example and Errors are Strings)

然后您可以使用以下递归函数在第一次失败时延迟停止处理它们:

Then you can process them lazily stopping at first failure using the following recursive function:

def processUntilFailure(l: Seq[() => Either[Error, Item]]): Either[Error, Seq[Item]] = {
  l.headOption.map(_.apply() match {
    case Left(error) => Left(error)
    case Right(item)  => processUntilFailure(l.tail).right.map(_ :+ item)
  }).getOrElse(Right(Nil))
}

所以现在当我运行 processUntilFailure(l)

scala> processUntilFailure(l)
1
2
3
res1: Either[Error,Seq[Item]] = Left(error)

如果你想生成一个Either[Seq[String], Seq[Int]](处理所有操作).你可以做一点改变:

If you wanted to generate a Either[Seq[String], Seq[Int]] (processing all the operations). You could do it with a little change:

def processAll(l: Seq[() => Either[Error, Item]]): Either[Seq[Error], Seq[Item]] = {
  l.headOption.map(_.apply() match {
    case Left(error) => processAll(l.tail) match {
      case Right(_) => Left(Seq(error))
      case Left(previousErrors) => Left(previousErrors :+ error)
    }
    case Right(item)  => processAll(l.tail).right.map(_ :+ item)
  }).getOrElse(Right(Nil))
}

您可以看到的唯一变化是模式匹配中的 Left 大小写.运行这个:

The only change as you can see is the Left case in the pattern match. Running this one:

scala> processAll(l)
1
2
3
4
5
res0: Either[Seq[Error],Seq[Item]] = Left(List(second error, error))

processAll 可以替换为 l

val zero: Either[Seq[Error], Seq[Item]] = Right(Seq[Item]())
l.foldLeft(zero) { (errorsOrItems: Either[Seq[Error], Seq[Item]], computation: () => Either[String, Int]) =>
  computation.apply().fold(
    { (error: String) => Left(errorsOrItems.left.toOption.map(_ :+ error).getOrElse(Seq(error))) },
    { (int: Int) => errorsOrItems.right.map(_ :+ int) })
}

processUntilFailure 也可以，但并不容易.因为从折叠中提前中止是很棘手的.当您发现自己需要这样做时，这里有一个关于其他可能方法的好答案.

processUntilFailure can as well but not easily. Since aborting early from a fold is tricky. Here's a good answer about other possible approaches when you find yourself needing to do that.

这篇关于在 Scala 中使用一系列按名称参数进行验证?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！