Cómo mantenerme fiel al estilo funcional en Scala para expresiones

Question

He luchado para encontrar una forma de mantenerme fiel al estilo funcional en expresiones cuando necesito recopilar múltiples parámetros de un objeto en una lista.

Como ejemplo, digamos que tengo un objeto de notificación, que tiene un fromId (el ID de usuario de la notificación es) y un objectOwnerId (el id del usuario que creó el objeto original). Estos pueden diferir en las notificaciones de estilo de Facebook ("X también comentó en la publicación de Y").

puedo recoger los userIds con una expresión como tal

val userIds = for { notification <- notifications } yield notification.fromId 

sin embargo digo que quiero para recoger tanto los fromIds y los objectOwnerIds en una sola lista, ¿hay alguna manera de hacer esto en una sola de expresión sin el usuario de vars?

que he hecho algo como esto en el pasado:

var ids = List() 
for { 
    notification <- notifications 
    ids = ids ++ List(notification.fromId, notification.objectOwnerId) 
} 
ids = ids.distinct 

pero se siente como que debe haber una mejor manera. El uso de una var y la necesidad de llamar distinct después de completar la colección son desagradables. Podría evitar lo distinto con algunos condicionales, pero estoy tratando de aprender los métodos funcionales adecuados para hacer las cosas.

¡Gracias de antemano por cualquier ayuda!

Answer 1

Para tales casos, hay foldLeft:

(notifications foldLeft Set.empty[Id]) { (set, notification) => 
    set ++ Seq(notification.fromId, notification.ownerId) 
} 

o en forma corta:

(Set.empty[Id] /: notifications) { (set, notification) => 
    set ++ Seq(notification.fromId, notification.ownerId) 
} 

Un conjunto no contiene duplicados. Después del doblez, puede convertir el conjunto a otra colección si lo desea.

Answer 2

Claro, en lugar de sólo produciendo el fromId, dió una tupla

val idPairs:List[(String, String)] = for(notification <- notifications) yield(notification.fromId, notification.objectOwnerId) 

Answer 3

Estoy de acuerdo con la solución de Dave, pero otro enfoque es doblar la lista, produciendo su mapa de identificación al objeto del usuario sobre la marcha. La función para aplicar En la tapa consultará el archivo db para ambos usuarios y los agregará al mapa que se está acumulando.

Answer 4

Bueno, aquí está mi respuesta a la siguiente:

cómo asignar de [Y (x1, x2), Y (x3, x4)] a [x1, x2, x3, x4]?

Uso flatMap (ver Collection.Traversable, pero tenga en cuenta que en realidad es la primera definido más arriba).

case class Y(a: Int, b: Int) 
var in = List(Y(1,2), Y(3,4)) 
var out = in.flatMap(x => List(x.a, x.b)) 

> defined class Y 
> in: List[Y] = List(Y(1,2), Y(3,4)) 
> out: List[Int] = List(1, 2, 3, 4) 

Además, dado que for..yield is filter, map and flatMap in one (pero también ver "sugar for flatMap?" que señala que esto no es tan eficiente como podría ser: no es un extra map):

var out = for { i <- in; x <- Seq(i.a, i.b) } yield x 

probable selección lo haría una de las otras respuestas, sin embargo, ya que esto no aborda directamente el problema final que se está resolviendo.

Happy coding.

Answer 5

val userIds = for { 
    notification <- notifications 
    id <- List(notification.fromId, notification.objectOwnerId) 
} yield id 

Aplicar distinct después si es necesario. Si la identificación solo se puede duplicar en una sola notificación, puede aplicar distinct en el segundo generador.

Answer 6

También puede utilizar la corriente para transformar los pares en una corriente de artículos individuales:

def toStream(xs: Iterable[Y]): Stream[Int] = { 
    xs match { 
    case Y(a, b) :: t => a #:: b #:: toStream(t) 
    case _ => Stream.empty 
    } 
} 

Pero como pst dijo, esto no soluciona el problema final de conseguir los valores distintos, pero una vez que haya la corriente es trivial:

val result = toStream(ys).toList.removeDuplicates 

O una ligera modificación a las sugerencias anteriores para utilizar aplanar - añadir una función que convierte una Y en una lista:

def yToList(y: Y) = List(y.a, y.b) 

entonces usted puede hacer:

val ys = List(Y(1, 2), Y(3, 4)) 
(ys map yToList flatten).removeDuplicates 

Answer 7

¿Qué pasa sencilla map? AFAIK for yield se convierte a series de flatMap y map de todos modos. Su problema podría resolverse simplemente como sigue:

notifications.map(n => (n.fromId, n.objectOwnerId)).distinct