Convertir una lista de opciones a una opción de lista usando Scalaz

Question

Quiero transformar un List[Option[T]] en un Option[List[T]]. El tipo de firma de la función es

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

El comportamiento esperado es mapear una lista que contiene sólo Some s en un Some que contienen una lista de los elementos dentro de los elementos Some 's. Por otro lado, si la lista de entrada tiene al menos un None, el comportamiento esperado es simplemente devolver None. Por ejemplo:

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

una implementación de ejemplo, y sin scalaz, sería:

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]]; 
}}} 

Recuerdo haber visto en alguna parte un ejemplo similar, pero usando Scalaz para simplificar el código. ¿Cómo se vería?

---

Una versión ligeramente más sucinta, utilizando Scala2.8 PartialFunction.condOpt, pero aún sin 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

Hay una función que convierte un List[Option[A]] en un Option[List[A]] en Scalaz. Es sequence. Para obtener None en caso de que alguno de los elementos son None y una Some[List[A]] en caso de que todos los elementos son Some, sólo puede hacer esto:

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

lo.sequence 

Este método se convierte en realidad F[G[A] en G[F[A]] dado que existe una implementación de Traverse[F] , y de Applicative[G] (Option y List resultan satisfacer ambos y son proporcionados por esas importaciones).

La semántica de Applicative[Option] son tales que si cualquiera de los elementos de un List de Option s son None, entonces el sequence habrá None también. Si desea obtener una lista de todos los Some valores independientemente de si otros valores son None, usted puede hacer esto:

lo flatMap (_.toList) 

Usted puede generalizar que para cualquier Monad que también forma una Monoid (List pasa a ser uno de ellos):

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

Por alguna razón que no le gusta

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

? Eso es probablemente el más corto en Scala sin Scalaz.

Answer 3

Mientras que el Applicative[Option] en Scalaz tiene el comportamiento incorrecto utilizar directamente MA#sequence, también puede derivar una Applicative de un Monoid. Esto se hace conveniente con MA#foldMapDefault o MA#collapse.

En este caso, usamos un Monoid[Option[List[Int]].Primero realizamos un mapa interno (MA#∘∘) para envolver el Int individual en List s de un elemento.

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

abstracción de List a cualquier recipiente con instancias para Traverse, Pointed y 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]] 

Lamentablemente, tratando de compilar este código actualmente ya sea desencadena #2741 o envía el compilador en un bucle infinito.

ACTUALIZACIÓN Para evitar que atraviesa la lista dos veces, debería haber utilizado foldMapDefault:

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

Esta respuesta se basó en la solicitud original que una lista vacía, o una lista que contiene sólo None s, debe devuelva un None. Por cierto, esto sería mejor modelado por el tipo Option[scalaz.NonEmptyList] - NonEmptyList garantiza al menos un elemento.

Si solo desea el a List[Int], hay muchas maneras más fáciles, dadas en otras respuestas. Dos formas directas que no se han mencionado:

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

Answer 4

Esto funcionó para mí. Espero que esta sea una solución correcta.

Retorna Ninguno si una de las opciones de la lista en su defecto, de lo contrario, devuelve la opción de Lista [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 

    } 
    } 

}