使用 Scalaz 将选项列表转换为列表选项

Question

我想将 List[Option[T]] 转换为 Option[List[T]]。函数的签名类型是

def lo2ol[T](lo: List[Option[T]]): Option[List[T]]

预期的行为是将仅包含 Some 的列表映射到包含元素 Some 内的元素列表的 Some 的。另一方面，如果输入列表至少有一个 None，则预期行为是仅返回 None。例如：

scala> lo2ol(Some(1) :: Some(2) :: Nil)
res10: Option[List[Int]] = Some(List(1, 2))

scala> lo2ol(Some(1) :: None :: Some(2) :: Nil)
res11: Option[List[Int]] = None

scala> lo2ol(Nil : List[Option[Int]])
res12: Option[List[Int]] = Some(List())

没有 scalaz 的示例实现将是：

def lo2ol[T](lo: List[Option[T]]): Option[List[T]] = {
  lo.foldRight[Option[List[T]]](Some(Nil)){(o, ol) => (o, ol) match {
    case (Some(x), Some(xs)) => Some(x :: xs);
    case _ => None : Option[List[T]]; 
}}}

我记得在某处看到过类似的示例，但使用 Scalaz 来简化代码。它会是什么样子？

---

一个稍微简洁的版本，使用 Scala2.8 PartialFunction.condOpt，但仍然没有 Scalaz：

import PartialFunction._

def lo2ol[T](lo: List[Option[T]]): Option[List[T]] = {
  lo.foldRight[Option[List[T]]](Some(Nil)){(o, ol) => condOpt(o, ol) {
    case (Some(x), Some(xs)) => x :: xs
  }
}}

Answer 1

Scalaz 中有一个函数可以将 List[Option[A]] 转换为 Option[List[A]]。这是序列。如果任何元素为 None，则获取 None；如果所有元素为 ，则获取 Some[List[A]]有些，你可以这样做：

import scalaz.syntax.traverse._
import scalaz.std.list._     
import scalaz.std.option._

lo.sequence

鉴于存在一个实现，此方法实际上将 F[G[A] 转换为 G[F[A]] Traverse[F] 和 Applicative[G] （Option 和 List 恰好满足两者并且是由这些进口提供）。

Applicative[Option] 的语义是这样的：如果 Option 的 List 中的任何元素为 None，那么sequence也将是None。如果您想获取所有 Some 值的列表，无论其他值是否为 None，您可以这样做：

lo flatMap (_.toList)

您可以将其推广到任何 Monad 也形成了 Monoid （List 恰好是其中之一）：

import scalaz.syntax.monad._

def somes[F[_],A](x: F[Option[A]])
                 (implicit m: Monad[F], z: Monoid[F[A]]) =
  x flatMap (o => o.fold(_.pure[F])(z.zero))

Answer 2

由于某种原因你不喜欢

if (lo.exists(_ isEmpty)) None else Some(lo.map(_.get))

？这可能是没有 Scalaz 的 Scala 中最短的。

Answer 3

开始 Scala 2.13，并添加 Option::unless 构建器到标准库，Rex Kerr 的答案的一个变体是：

Option.unless(list contains None)(list.flatten)
// val list = List(Some(1), Some(2))          =>    Some(List(1, 2))
// val list = List(Some(1), None, Some(2))    =>    None

或者，如果性能受到威胁（为了避免flatten 从 Option 到 List 的隐式转换）：

Option.unless(list contains None)(list.map(_.get))

Answer 4

虽然 Scalaz 中的 Applicative[Option] 直接使用 MA#sequence 的行为是错误的，但您也可以从 Applicative 派生一个 Applicative >幺半群。使用 MA#foldMapDefault 或 MA#collapse 可以方便地实现这一点。

在本例中，我们使用 Monoid[Option[List[Int]]。我们首先执行一个内部映射 (MA#∘∘)，将各个 Int 包装在一个元素的 List 中。

(List(some(1), none[Int], some(2)) ∘∘ {(i: Int) => List(i)}).collapse assert_≟ some(List(1, 2))
(List(none[Int]) ∘∘ {(i: Int) => List(i)}).collapse                   assert_≟ none[List[Int]]
(List[Option[Int]]() ∘∘ {(i: Int) => List(i)}).collapse               assert_≟ none[List[Int]]

从 List 抽象到具有 Traverse、Pointed 和 Monoid 实例的任何容器：

def co2oc[C[_], A](cs: C[Option[A]])
                  (implicit ct: Traverse[C], cp: Pointed[C], cam: Monoid[C[A]]): Option[C[A]] =
  (cs ∘∘ {(_: A).pure[C]}).collapse


co2oc(List(some(1), none[Int], some(2)))   assert_≟ some(List(1, 2))
co2oc(Stream(some(1), none[Int], some(2))) assert_≟ some(Stream(1, 2))
co2oc(List(none[Int]))                     assert_≟ none[List[Int]]
co2oc(List[Option[Int]]())                 assert_≟ none[List[Int]]

遗憾的是，尝试编译此代码目前要么触发 #2741 要么让编译器进入无限循环。

更新
为了避免遍历列表两次，我应该使用 foldMapDefault：

(List(some(1), none[Int], some(2)) foldMapDefault (_ ∘ ((_: Int).pure[List])))

这个答案基于原始请求，即应返回空列表或仅包含 None 的列表无。顺便说一句，这最好通过 Option[scalaz.NonEmptyList] 类型进行建模 - NonEmptyList 保证至少有一个元素。

如果您只想要一个 List[Int]，有很多更简单的方法，在其他答案中给出。没有提到的两种直接方式：

list collect { case Some(x) => x }
list flatten

Answer 5

这对我有用。我希望这是一个正确的解决方案。

如果列表中的选项之一为 None，则返回 None，否则返回 List[A] 的选项

def sequence[A](a: List[Option[A]]): Option[List[A]] = {

  a.foldLeft(Option(List[A]())) {
    (prev, cur) => {

      for {
        p <- prev if prev != None
        x <- cur
      } yield x :: p

    }
  }

}