Question

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

我知道Scalaz可以完成这项工作，但是现在我完全不理解Scalaz的所有部分，我很确定有一种更简单的方法可以在不使用Scalaz的情况下完成它，但是使用by-name参数例如。< / p>

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

我的意思是某种类型Seq[=> Either[Error,Item]] 那么我可以做一些事情，比如调用takeWhile或collectFirst或somilar，而不是在创建序列之前执行所有操作？我希望只有在迭代序列时才能执行操作。

由于

Answer 1

您确实可以使用Seq[() => Either[Error, Item]]在创建集合时推迟计算。例如，

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)

（Item s在示例中为Int，Error为String s）

然后你可以使用以下递归函数在第一次失败时懒洋洋地停止它们：

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]]（处理所有操作）。你可以做一点改变：

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))
}

您可以看到的唯一变化是模式匹配中的左侧案例。运行这个：

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

processAll可以替换为foldLeft

上的通用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也可以，但不容易。因为从折叠中提前中止是棘手的。当你发现自己需要这样做时，这是一个good answer about other possible approaches。

Answer 2

您应该可以使用Seq[Function0[Either[Error, Item]]]类型将其拉出。 Function0显然是一个零参数函数。其余的应该是不言自明的。

Scalaz正是为了这个目的提供了类型IO，所以你也可以实际使用它。但是，如果你刚刚开始使用Scalaz，你可能还不想。

在Scala中使用一系列按名称参数进行验证？

2 个答案: