Meilleur moyen de marquer et de la somme en Scala?

Est-il une meilleure manière de faire ceci:

val totalScore = set.foldLeft(0)( _ + score(_) )

ou ceci:

val totalScore = set.toSeq.map(score(_)).sum

Je pense que c'est plutôt une opération commune ainsi m'attendais à quelque chose de plus lisse comme:

val totalScore = set.sum( score(_) )
Les deux premiers morceaux de code à faire des choses différentes. Voir mon commentaire de Daniel C. Sobral de réponse.
Merci @dsg, je l'ai changé.

OriginalL'auteur adam77 | 2010-05-21

  1. 17

    Bien, il y a d'autres façons de l'écrire:

    val totalScore = set.toSeq.map(score(_)).sum
val totalScore = set.toSeq.map(score).sum
val totalScore = set.toSeq map score sum

    Le dernier peut exiger un point-virgule à la fin si la ligne suivante ne commence pas avec un mot-clé. On peut aussi utiliser .view au lieu de .toSeq, ce qui permettrait d'éviter l'allocation temporaire de la collection. Cependant, je ne suis pas sûr de la .views'présente le comportement (en montrant les éléments répétés) est la bonne.

    Cela semble le plus simple et le plus approprié de la solution. Je préfère lire plutôt que d'avoir une fonction qui comprend la cartographie.
    Une préoccupation légitime avec l'approche en deux étapes peut être la représentation, il crée une seconde liste de somme. Toutefois, vous pouvez utiliser une vue d'éviter cela: set.view.map(score).sum. Séparer la question de la cartographie et en additionnant évite un coup de méthodes dans la bibliothèque standard. Si vous le faites souvent, vous pouvez ajouter mapAndSum à votre propre code.
    Quelqu'un aurait-il un lien vers de la documentation sur les points de vue?
    Ce code a un bug! À savoir, si set est en effet de type Set[_] et score attribue la même valeur à deux éléments de set (c'est à dire score(a) = score(b) où a, b sont en set et a != b), alors ils ne sont comptés qu'une fois. Par conséquent, il n'est pas seulement que le "paresseux" set.view.map.(score(_)).sum est plus performant, c'est en fait la seule façon correcte de le faire! (En fait je viens de rencontré ce bug dans mon code).
    Grande pêche. Si l'on peut toujours faire un toSeq à la place.

    OriginalL'auteur Daniel C. Sobral

  2. 5

    Seq.sum ne prend pas une fonction qui pourrait être utilisé pour marquer de la somme. Vous pouvez définir une conversion implicite qui "souteneurs" Traversable:

    implicit def traversableWithSum[A](t: Traversable[A])(implicit m: Numeric[A]) = new {
  def sumWith(f: A => A) = t.foldLeft(m.zero)((a, b) => m.plus(a, f(b)))
}

def score(i: Int) = i + 1

val s = Set(1, 2, 3)

val totalScore = s.sumWith(score _)
println(totalScore)
=> 9

    Veuillez noter que le Numeric trait n'existe que dans Scala 2.8.

    Michel, j'aime votre solution et j'ai pensé que je le ferais un peu plus générique, en permettant score de travailler sur un objet, comme "Jeu" et de retour Numérique: implicite def traversableWithSum[A](t: Traversable[A]) = { def sumWith[B](f: A => B)(implicite m: Numérique[B]): B = t.foldLeft(m.zéro)((a, b) => m.plus(a, f(b))) }

    OriginalL'auteur Michel Krämer

  3. 1

    De plus simple:

    scala> val is1 = Set(1, 4, 9, 16)
is1: scala.collection.immutable.Set[Int] = Set(1, 4, 9, 16)
scala> is1.reduceLeft(_ + _)
res0: Int = 30

    Avec votre score méthode:

    scoreSet.reduceLeft(_ + score(_))

    Avertissement, cependant, cet échec est la collection en cours de réduction est vide tandis que le pli n'est pas:

    scala> val is0 = Set[Int]()
is0: scala.collection.immutable.Set[Int] = Set()

scala> is0.foldLeft(0)(_ + _)
res1: Int = 0
    Cela ne fonctionnera pas. Le type de la collection est différente du type du résultat (ce qui est la raison de l'appel à score), de sorte reduceLeft n'est pas une option.

    OriginalL'auteur Randall Schulz

  4. 1

    Tour à tour, les Seq#sum surcharge qui prend une conversion implicite en Numeric peut être utilisé si le type de la collection à être marqué /résumé n'est pas en elle-même un opérateur d'addition. Toutefois, parce que c'est une conversion implicite paramètre, il ne sera pas appliquée si nécessaire pour faire de l'réduire fermeture de type case.

    OriginalL'auteur Randall Schulz