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

Question

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

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

预期的行为是映射仅包含Some s转换为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

有一个函数可以将斯卡拉兹的List[Option[A]]变成Option[List[A]]。这是sequence。要在情况下，任何元素都是None得到None和万一Some[List[A]]所有的元素都Some，你可以这样做：

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]的语义是使得如果任何OptionList的一个S的元素是None，那么sequence将None为好。如果你想获得的所有Some值的列表，无论任何其他值是否None，你可以这样做：

lo flatMap (_.toList) 

可以概括，对于还形成一个Monoid（List恰好是任何Monad其中之一）：

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

虽然Scalaz的Applicative[Option]有错误的行为直接使用MA#sequence，你也可以从一个Monoid导出Applicative。这通过MA#foldMapDefault或MA#collapse来实现。我们使用Monoid[Option[List[Int]]。我们首先执行内部映射（MA#∘∘）以将单个Int s包含在一个元素的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或编译器送入一个无限循环。

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

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

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

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

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

Answer 4

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

如果在列表中的选项之一是无返回None，否则返回列表[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 

    } 
    } 

}