Scala: utilizzare la custodia per Map.flatten?

Question

I documentation on Map.flatten stati i seguenti:

Converte questa mappa delle collezioni percorribili in una mappa formata dagli elementi di queste collezioni attraversabili.

Ottengo "la mappa di collezioni attraversabili". Questa sarebbe una mappa di liste, per esempio. Solo con questa definizione, si qualificherà uno Map[Int, List[Int]].

Ma che cos'è "una mappa formata dagli elementi di queste collezioni attraversabili"? Sembra semplice, ma sto facendo fatica a farlo funzionare.

Il codice di esempio fornito nella documentazione è ... beh ... dovremmo dire non applicabile?

val xs = List(
      Set(1, 2, 3), 
      Set(1, 2, 3) 
     ).flatten 
// xs == List(1, 2, 3, 1, 2, 3) 

val ys = Set(
      List(1, 2, 3), 
      List(3, 2, 1) 
     ).flatten 
// ys == Set(1, 2, 3) 

Ho provato un paio di cose diverse, ma cedono lo stesso errore. Ecco un paio di esempi:

scala> val m = Map(List(1) -> List(1,2,3), List(2) -> List(4,5,6), List(3) -> List(7,8,9)) 
m: scala.collection.immutable.Map[List[Int],List[Int]] = Map(List(1) -> List(1, 2, 3), List(2) -> List(4, 5, 6), List(3) -> List(7, 8, 9)) 

scala> m.flatten 
<console>:9: error: No implicit view available from (List[Int], List[Int]) => scala.collection.GenTraversableOnce[B]. 
       m.flatten 
       ^

scala> val m = Map(1 -> List(1,2,3), 2 -> List(4,5,6), 4 -> List(7,8,9)) 
m: scala.collection.immutable.Map[Int,List[Int]] = Map(1 -> List(1, 2, 3), 2 -> List(4, 5, 6), 4 -> List(7, 8, 9)) 

scala> m.flatten 
<console>:9: error: No implicit view available from (Int, List[Int]) => scala.collection.GenTraversableOnce[B]. 
       m.flatten 
       ^

Cosa mi manca?

Answer 1

Il problema è che il compilatore non "sa" come interpretare gli elementi che si memorizzano nella mappa. Cioè, l'interpretazione non è evidente, quindi devi fornire la tua visione implicita degli elementi in un attraversabile. Ad esempio, per il caso che si fornisce, si desidera interpretare ogni elemento della mappa di tipo (Int, List[Int]) in un nuovo elenco di tuple in cui il primo elemento è la chiave dell'elemento originale e il valore è ciascuno dei valori originariamente nel dato valore della chiave. Nel codice:

implicit val flattener = (t: (Int,List[Int])) ⇒ t._2.map(x ⇒ (t._1, x)) 

val m = Map(1 → List(1, 2, 3), 2 → List(4, 5), 3 → List(6)) 
val fm = m.flatten 

Ma è necessario fornire da soli la funzione "spianatura".