Question

我正在玩Scala（z）学习功能编程。

我的类型为Future[List[Error \/ Double]]，并希望将其转换为Future[[List[Error] \/ List[Double]]类型的值。

目标是对左派和权利进行分组。

我目前有以下内容：

val foo: Future[List[Error] \/ List[Double]] = {
  for {
    results <- resultsF
  } yield
    results.foldLeft(\/[List[Error], List[Double]])({
      case (acc, v) if v.isRight => v :: \/-(acc)
      case (acc, v) if v.isLeft => v :: -\/(acc)
    })
}

但是，我在::上收到错误，这是因为我的累加器不是列表（来自外部）\/[List[Error], List[Double]]。应该怎么做？

Answer 1

Haskell中的这个函数是partitionEithers：[Either a b] -> ([a], [b])。

（你实际上并不想要Either [a] [b]，这真的没有意义。我猜你想要这个功能，因为你的描述中的文字...）

Scalaz并没有原样。但是，它有一个更通用的separate：

/** Generalized version of Haskell's `partitionEithers` */
def separate[G[_, _], A, B](value: F[G[A, B]])(implicit G: Bifoldable[G]): (F[A], F[B])

基本上是Bifoldable g, MonadPlus f => f (g a b) -> (f a), (f b)。具体来说：[Either a b] -> ([a], [b])。您只需在列表中调用它（g = \/（或任何一个），f = List）。

行动中：

scala> import scalaz._, Scalaz._
scala> List(\/-(3), -\/("a")).separate
res1: (List[String], List[Int]) = (List(a),List(3))

Answer 2

严格来说，您可以实现此类功能，例如，如何应用此列表：

-\/(A) :: \/-(B) :: Nil

假设输入列表全部保留或完全正确，您可以查看第一个输入列表，并决定如何处理遗体：

val foo: Future[List[Error] \/ List[Double]] =
  resultsF.map(resultsF.head match {
    case -\/(_) => { _.left }
    case \/-(_) => { _.right }
  })

假设您要分组左侧和右侧，返回的单个折叠（List [L]，List [R]）完美地运行：

val foo[L,R]: Future[(List[L], List[R])] =
  resultsF.foldr((Nil, Nil)){ (s, v) =>
    case -\/(l) => (l :: s._1, s._2)
    case \/-(r) => (s._1, r :: s._2)
  }

未来[List [Error \ / Double]]到Scala中的Future [[List [Error] \ / List [Double]]

2 个答案: