Carte aplatir et flatmap pas d'équivalent

Je pensais que Scala construction map(f).aplatir est équivalent à flatMap(f). Mais avec cet exemple, il n'est pas le cas. Je me demande quel est le rôle de la classe de cas. Si je utiliser les nombres entiers, les deux sont équivalents. Mais dans mon cas, je ne peux pas.

case class CTest(v: Int)
val s = Set(Map(CTest(0) -> List(0, 3), CTest(1) -> List(0, 2)))
val possibilities = s flatMap { m =>
  val mapping = m flatMap {
    case (label, destNodes) => destNodes map {
      case nodes => (label, nodes) }
  }
  mapping
}
possibilities

Rendements

Set((CTest(0),3), (CTest(1), 2))

alors que

case class CTest(v: Int)
val s = Set(Map(CTest(0) -> List(0, 3), CTest(1) -> List(0, 2)))
val possibilities = s flatMap { m =>
  val mapping = m map {
    case (label, destNodes) => destNodes map {
      case nodes => (label, nodes) }
  }
  mapping.flatten
}
possibilities

rendements

Set((CTest(0),0), (CTest(0),3), (CTest(1),0), (CTest(1),2))

Aucune idée pourquoi?

OriginalL'auteur Mikaël Mayer | 2013-11-26

  1. 7

    Prendre un coup d'oeil à la mise en œuvre de flatMap:

    def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
  def builder = bf(repr) //extracted to keep method size under 35 bytes, so that it can be JIT-inlined
  val b = builder
  for (x <- this) b ++= f(x).seq
  b.result
}

    Résultat de flatMap dépend collection originale type et le type de résultat de la fonction f. Dans le premier exemple, vous générez de la séquence des n-uplets de la carte, de sorte que le compilateur choisit de mise en œuvre comme CanBuildFrom[Map[A, B], (C, D), Map[C, D]], qui fournit builder pour Map, qui provoque l'écrasement des mêmes touches.

    Vous pouvez convertir directement la carte à la plaine de itératif, qui donnera le résultat que vous souhaitez:

    case class CTest(v: Int)
val s = Set(Map(CTest(0) -> List(0, 3), CTest(1) -> List(0, 2)))
val possibilities = s flatMap { m =>
  val mapping = m.toIterable.flatMap {
    case (label, destNodes) => destNodes map {
      case nodes => (label, nodes) }
  }
  mapping
}
possibilities

    OriginalL'auteur chemikadze

  2. 10

    Cela se produit en raison d'un niveau intermédiaire de structures de données.

    Je vais prendre la version simple de votre exemple.

    val m = Map(CTest(0) -> List(0, 3), CTest(1) -> List(0, 2))

    Lors de l'utilisation de flatMap vous de créer directement un Map[CTest, Int]

    scala> m flatMap {
 |     case (label, destNodes) => destNodes map {
 |       case nodes => (label, nodes) }
 |   }
res3: scala.collection.immutable.Map[CTest,Int] = Map(CTest(0) -> 3, CTest(1) -> 2)

    Ici, en raison de l'unicité des clés de Map, (CTest(0), 0) et (CTest(1), 0) seront supprimées à partir du résultat. lorsque vous flatMap fil du jeu, vous obtiendrez un Set de Tuples qui étaient dans la Map.

    Dans votre deuxième exemple, la carte et les aplatir.

    val mapping = m map {
 |     case (label, destNodes) => destNodes map {
 |       case nodes => (label, nodes) }
 |   }
mapping: scala.collection.immutable.Iterable[List[(CTest, Int)]] = List(List((CTest(0),0), (CTest(0),3)), List((CTest(1),0), (CTest(1),2)))

mapping.flatten
res4: scala.collection.immutable.Iterable[(CTest, Int)] = List((CTest(0),0), (CTest(0),3), (CTest(1),0), (CTest(1),2))

    Il n'est pas tout Map ou d'une autre singularité conservé la structure de données créée dans le milieu du processus. De sorte que les valeurs ne sont pas abandonnées.

    OriginalL'auteur tiran