Scala: mappa a Mappa per elenco tuple

Question

Ho provato a utilizzare Map.map per convertire una mappa in un elenco di tuple. Tuttavia questo fallisce. Ho fatto i seguenti esperimenti:

val m = Map(("a" -> 1), ("b" -> 2)) 
     //> m :  scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2) 
val r1 = m.map{ case (k,v) => v}    //> r1 : scala.collection.immutable.Iterable[Int] = List(1, 2) 
def toTuple[A,B](a:A,b:B) = (a,b)    //> toTuple: [A, B](a: A, b: B)(A, B) 
//val r2: List[Tuple2[_,_]] = m.map(e => (e._1,e._2)) 
val r3 = m.map(e => toTuple(e._1,e._2))   //> r3 : scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2) 
val r4 = m.toSeq        //> r4 : Seq[(String, Int)] = ArrayBuffer((a,1), (b,2)) 

Si noti come una lista è generato per singoli elementi (R1), ma una mappa viene prodotto per le tuple (r3). Non forzare nemmeno il tipo lavorato (r2). Solo una chiamata esplicita a Seq l'ha fatto (r4) Quindi la mia domanda è: perché/come Map.map "automagicamente" crea una nuova mappa e non una lista per esempio? Infatti come è il tipo di reddito determinato (Seq, List, ecc)

Answer 1

Un Map è un insieme di tuple già.

scala> "b" -> 2 
res0: (String, Int) = (b,2) // Implicitly converted to a Tuple 

Quando sei la mappatura di un Map, si sta mappando le coppie (chiave, valore) che esso contiene. Questo non può funzionare, perché stai rimuovendo le chiavi e mantenendo solo i valori. Quindi, quello che hai non è più una Map, ma un passo o due nella gerarchia di raccolta, un Iterable:

val r1 = m.map{ case (k,v) => v} 

Forzare il tipo non può funzionare, perché un Map[A, B] non è un List[(A, B)]. Questo è l'equivalente di m.map(identity). Notate come si sta ancora accedendo e con funzioni di accesso tuple:

val r2: List[Tuple2[_,_]] = m.map(e => (e._1,e._2)) 

val r3 = m.map(e => toTuple(e._1,e._2)) 

Qui, Seq è più generalizzata di List:

val r4 = m.toSeq 

La soluzione semplice quanto affermato dal @EndeNeu è usare solo toList. Se hai una collezione map, dovrebbe restituire il tipo di raccolta originale, se possibile. Pertanto, la mappatura di Map deve restituire un altro Map, a meno che la struttura sottostante non lo abbia reso più un Map (come la rimozione completa delle chiavi) in r1.