En Scala, comment puis-je faire l'équivalent d'un SQL SOMME et de GROUPE?

Par exemple, supposons que j'ai

val list: List[(String, Double)]

avec des valeurs

"04-03-1985", 1.5
"05-03-1985", 2.4
"05-03-1985", 1.3

Comment ai-je pu produire une nouvelle Liste

"04-03-1985", 1.5
"05-03-1985", 3.7

OriginalL'auteur deltanovember | 2011-08-22

scala

28

Voici un one-liner. Ce n'est pas très lisible, à moins de vraiment intériorise les types de ces des fonctions d'ordre supérieur.
```
val s = Seq(("04-03-1985" -> 1.5),
            ("05-03-1985" -> 2.4),
            ("05-03-1985" -> 1.3))

s.groupBy(_._1).mapValues(_.map(_._2).sum)
//returns: Map(04-03-1985 -> 1.5, 05-03-1985 -> 3.7)
```
Une autre approche consiste à ajouter les paires clé-valeur d'un-à-un à l'aide de pli,
```
s.foldLeft(Map[String, Double]()) { case (m, (k, v)) =>
  m + (k -> (v + m.getOrElse(k, 0d)))
}
```
L'équivalent pour la compréhension est le plus accessible, à mon avis,
```
var m = Map[String, Double]()
for ((k, v) <- s) {
  m += k -> (v + m.getOrElse(k, 0d))
}
```
Peut-être quelque chose de plus sympa peut être fait avec Scalaz du monoïde typeclass pour la Carte.

Notez que vous pouvez convertir entre Map[K, V] et Seq[(K, V)] à l'aide de la toSeq et toMap méthodes.

Mise à jour. Après y réfléchissant un peu plus, je pense que le naturel de l'abstraction serait un "multimap" conversion de type,
```
def seqToMultimap[A, B](s: Seq[(A, B)]): Map[A, Seq[B]]
```
Avec les implicites de l'extension dans une bibliothèque personnelle, on peut alors écrire:
```
s.toMultimap.mapValues(_.sum)
```
C'est le meilleur de tous, à mon avis!

"Il n'est pas particulièrement lisible" je pense que c'est parfaitement lisible. Ce genre de phrases me rendre heureux, je suis en train d'apprendre Scala.
Ouais, j'ai édité mon post pour se qualifier "lisibilité" -- pour quelqu'un qui est profondément familier avec le sens de l' groupBy et mapValues, OK, la version concise est la meilleure. Mais il est difficile de en déduire le sens de ces fonctions à partir de l'expression concise, et pour rusty Scala programmeurs (comme moi) je pense que la compréhension serait la plus facile à comprendre.
Je l'ai lu de post-édition. Je n'avais jamais entendu parler de soit groupBy et mapValues (je suis nouveau à la Scala), mais ils étaient exactement ce que j'ai espérait Scala aurait. De gustibus non disputandum comme ma mère a toujours dit, mais votre première solution a le minimum de trucs et j'ai donc trouver le plus accessible.
J'apprécie votre point de vue. Quand je rencontre des modèles de programmation, qui repoussent les limites de mon mémoire de travail, je trouve souvent il est utile d'abstraction qui simplifie grandement les choses. Dans ce cas, je pense que le droit d'abstraction est toMultimap. Un autre exemple: le typeclasses en Haskell/Scalaz comme Foncteur, Applicative, Monade..., ont un coût à apprendre, mais une fois compris, leur application simplifie ultérieure de haut niveau de modèles.
Le plus clair serait quelque chose comme s.groupBy(_._1).mapValues(_.sumBy(_._2)). Ayant conversions implicites qui ne sumBy, avgBy pourrait être assez cool.

OriginalL'auteur Kipton Barros
14

Il y a une autre possibilité, à l'aide de Scalaz.

Le point clé est d'avis que, si M est un Monoid, puis Map[T, M] est aussi un Monoid. Cela signifie que si j'ai 2 cartes, m1 et m2 que je peux ajouter, de sorte que, pour chaque clé similaires, les éléments seront ajoutés ensemble.

Par exemple, Map[String, List[String]] est un Monoïde parce que List[String] est un Monoid. Le cas échéant Monoid exemple dans le champ d'application, je devrais être capable de faire:
```
  val m1 = Map("a" -> List(1), "b" -> List(3))
  val m2 = Map("a" -> List(2))

  //|+| "adds" two elements of a Monoid together in Scalaz
  m1 |+| m2 === Map("a" -> List(1, 2), "b" -> List(3))
```
Pour votre question, nous pouvons voir que Map[String, Int] est un Monoid car il y a un Monoid exemple pour la Int type. Nous allons importer:
```
  implicit val mapMonoid = MapMonoid[String, Int]
```
Puis j'ai besoin d'une fonction reduceMonoid, qui prend tout ce qui est Traversable et ajoute" ses éléments avec un Monoid. Je viens d'écrire le reduceMonoid de définition, de mise en œuvre complète, veuillez vous référer à mon post sur le L'Essence de l'Itérateur Modèle:
```
  //T is a "Traversable"
  def reduce[A, M : Monoid](reducer: A => M): T[A] => M
```
Ces 2 définitions n'existent pas dans le courant de Scalaz de la bibliothèque, mais ils ne sont pas difficiles à ajouter (sur la base de Monoid et Traverse typeclasses). Et une fois que nous les avons, la solution à votre question est très simple:
```
  val s = Seq(("04-03-1985" -> 1.5),
              ("05-03-1985" -> 2.4),
              ("05-03-1985" -> 1.3))

   //we just put each pair in its own map and we let the Monoid instance
   //"add" the maps together
   s.reduceMonoid(Map(_)) === Map("04-03-1985" -> 1.5,
                                  "05-03-1985" -> 3.7)
```
Si vous estimez que le code ci-dessus est un peu obscure (mais vraiment concis, non?), Je vous invite à consulter le projet github pour les EIP post et de jouer avec elle. Un exemple montre la solution à votre question:
```
   "I can build a map String->Int" >> {
     val map1 = List("a" -> 1, "a" -> 2, "b" -> 3, "c" -> 4, "b" -> 5)
     implicit val mapMonoid = MapMonoid[String, Int]

     map1.reduceMonoid(Map(_)) must_== Map("a" -> 3, "b" -> 8, "c" -> 4)
   }
```
Scalaz est vraiment impressionnant. Très sympa!
+1. Vous devriez probablement commencer à bloguer à propos de ces simples cas d'utilisation où l'on peut commencer à intégrer Scalaz dans leur projet. 🙂 Va encourager plus de gens à regarder dans Scalaz et algébrique de la programmation fonctionnelle.

OriginalL'auteur Eric
9

J'ai utilisé ce modèle s.groupBy(_._1).mapValues(_.map(_._2).sum) de Kipton la réponse de tous les temps. Il traduit assez directement mon processus de pensée, mais malheureusement n'est pas toujours facile à lire. J'ai trouvé que l'utilisation de la classe de cas chaque fois que possible, rend les choses un peu mieux:
```
case class Data(date: String, amount: Double)
val t = s.map(t => (Data.apply _).tupled(t))
//List(Data(04-03-1985,1.5), Data(05-03-1985,2.4), Data(05-03-1985,1.3))
```
Il devient alors:
```
t.groupBy(_.date).mapValues{ group => group.map(_.amount).sum }
//Map(04-03-1985-> 1.5, 05-03-1985 -> 3.7)
```
Je pense que c'est plus lisible que le fois ou pour version.

OriginalL'auteur huynhjl

val s = List ( "04-03-1985" -> 1.5, "05-03-1985" -> 2.4, "05-03-1985" -> 1.3)
for { (key, xs) <- s.groupBy(_._1)
       x = xs.map(_._2).sum
    } yield (key, x)

OriginalL'auteur anrizal - Anwar Rizal

Vous devez vous connecter pour publier un commentaire.