Scala meilleur moyen de transformer une collection en carte-par-clé? (2e variante)

Question

(Ceci est une variante à this Q&A)

Dire que j'ai ceci:

List("foo", "bar", "spam") 

Je veux créer une carte pour laquelle la clé est la longueur de la chaîne et la valeur est une collection de toutes les chaînes qui ont cette longueur. En d'autres termes, compte tenu de la liste au sujet, nous obtiendrions:

Map(3 -> List(foo, bar), 4 -> List(spam)) 

Le code que j'ai écrit pour ce faire est:

list.foldLeft(Map[Long, List[String]]()) { 
    (m, s) => m(s.length) = s :: 
    (if (m.contains(s.length)) m(s.length) 
     else Nil) 
} 

Cela fonctionne, mais il ajoute beaucoup de laideur la réponse élégante donnée par Daniel Spiewak à la question originale (référencée ci-dessus).

Des idées pour améliorer la solution pour ma variante?

Merci! Sean

Answer 1

Si cela ne vous dérange pas les performances moche:

val list = List("foo", "bar", "spam") 
val keyValue = for (length <- list map (_ length) removeDuplicates; 
        strings = list filter (_.length == length)) 
       yield (length -> strings) 
val map = Map(keyValue: _*) 

Le problème est que la liste est lue à nouveau pour chaque longueur différente.

Maintenant, au sujet de la laideur de votre version, peut-être cette aide:

list.foldLeft(Map[Long, List[String]]()) { 
    (m, s) => m(s.length) = s :: m.getOrElse(s.length, Nil) 
} 

mieux? Ce n'est toujours pas très bon parce que vous obtenez la longueur deux fois. Celui-ci n'a pas ce problème, mais il est un peu plus laid:

list.foldLeft(Map[Long, List[String]]()) { 
    (m, s) => val length = s.length; m(length) = s :: m.getOrElse(length, Nil) 
} 

Answer 2

Avec Scala 2.8.0:

list.groupBy(_.length) 

Il ne peut pas être plus simple que ça!