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

Question

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

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

预期的行为是将仅包含Somes 的列表映射到包含元素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]]。这是sequence。要在任何元素为 None 的情况下获取 None，在所有元素为 Some 的情况下获取 Some[List[A]]，您可以这样做：

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

lo.sequence

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

Applicative[Option] 的语义是这样的，如果Options 的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's answer 的变体将是：

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 的错误行为，但您也可以从 Monoid 派生 Applicative。使用MA#foldMapDefault 或MA#collapse 可以很方便。

在这种情况下，我们使用Monoid[Option[List[Int]]。我们首先执行一个内部映射 (MA#∘∘) 以将单个 Ints 包装在一个元素的 Lists 中。

(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])))

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

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

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

Answer 5

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

如果 List 中的 Options 之一为 None，则返回 None，否则返回 List[A] 的 Option

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

    }
  }

}