La réaffectation à un val en Scala

Je suis en train de faire un exercice d'entraînement à la Scala et de l'obtention de ce val de réaffectation d'erreur. Je ne vois pas où je suis, la réaffectation d'une valeur de un val

class personTest
{
  val alf = Person("Alf", 30, List(EmailAddress("[email protected]")))
  val fredrik = Person("Fredrik", 33, List(EmailAddress("[email protected]"), EmailAddress("[email protected]")))
  val johannes = Person("Johannes", 0, Nil)

  val persons = List(alf, fredrik, johannes)

   @Test
  def testNameToEmailAddress
  {
    //Create a map from each persons name to their e-mail addresses,
    //filtering out persons without e-mail addresses
    //Hint: First filter list, then use foldLeft to accumulate...
    val emptyMap: Map[String, List[EmailAddress]] = Map()

    val nameToEmail = persons.filter(_.emailAddresses.length>0).foldLeft(emptyMap)((b,p)=> b+=p.name->p.emailAddresses)

    assertEquals(Map(alf.name -> alf.emailAddresses, fredrik.name -> fredrik.emailAddresses), nameToEmail)
  }

}

et j'obtiens cette erreur

error: reassignment to val
val nameToEmail = persons.filter(_.emailAddresses.length>0).foldLeft(emptyMap)((b,p)=> b+=p.name->p.emailAddresses)

OriginalL'auteur Mansur Ashraf | 2010-10-11

  1. 9

    b qui est le nom d'un paramètre de votre clôture est lui-même un val, qui ne peut être réattribué.

    foldLeft fonctionne en prenant en passant la valeur de retour d'une invocation de la fermeture en tant que paramètre b à l'autre, de sorte que tous vous avez besoin à faire est de retour b + (p.name->p.emailAddresses). (N'oubliez pas les parenthèses pour la préséance.)

    OriginalL'auteur Ken Bloom

  2. 3

    Vous êtes à la réaffectation val b dans l'expression b+=p.name->p.emailAddresses.

    OriginalL'auteur Aaron Novstrup

  3. 3

    Immuable Map ne dispose pas d'un += méthode. Dans de tels cas, le compilateur traduit b += p.name -> p.emailAddresses à b = b + p.name->p.emailAddresses. Là vous l'avez, réaffectation!

    Merci, j'ai changé la carte pour une mutable carte et cela a fonctionné. Pas sûr si c'est la bonne solution si
    Pas besoin d'utiliser une mutable carte. Vous devriez changer de += à + à la place (comme l'a déjà suggéré par @Ken Bloom).

    OriginalL'auteur missingfaktor

  4. 0

    Comme mentionné précédemment, le message d'erreur est originaire de l'expression ...b+=bp.name...

    Mais vraiment, vous n'avez pas besoin de faire un foldLeft ici, à tous, une simple cartographie devrait être suffisant. Tout Seq[K->V] peut ensuite être convertie en une Map[K,V] via le toMap méthode.

    Quelque chose comme ceci:

    avertissement: pas testé pour les fautes de frappe, etc.

    class personTest {
  val alf = Person(
    "Alf",
    30,
    EmailAddress("[email protected]") ::
    Nil
  )

  val fredrik = Person(
    "Fredrik",
    33,
    EmailAddress("[email protected]") ::
    EmailAddress("[email protected]") ::
    Nil)

  val johannes = Person(
    "Johannes",
    0,
    Nil)

  val persons = List(alf, fredrik, johannes)

  @Test
  def testNameToEmailAddress {

    val nameToEmailMap =
      persons.view filter (!_.emailAddresses.isEmpty) map {
        p => p.name -> p.emailAddresses
      } toMap

    assertEquals(
      Map(
        alf.name -> alf.emailAddresses,
        fredrik.name -> fredrik.emailAddresses
      ),
      nameToEmailMap
    )
  }
}
    La définition d'une conversion implicite de String à EmailAddress semble exagéré. 🙂
    Vrai, mais le code est tellement boilerplatey, et dans l'ensemble, pour essayer de s'intégrer dans la fenêtre StackOverflow
    J'aime le DPP devis (à partir de son livre): "je pense à implicites comme je pense que des vampires. Ils sont très puissant et très dangereux, et je ne les inviter dans mon programme de la portée quand il ya une très bonne raison."
    Utilisé correctement limité la portée je pense que implicites sont parfaitement sûrs, en particulier les conversions implicites de types utilisés en lieu et place de typage dynamique. Une conversion implicite ici est essentiellement en déclarant que "je peux fournir une Chaîne de caractères à chaque fois qu'une Adresse e-mail est attendu", ce qui semble raisonnable genre de déclaration. Vous déposez le passe-partout de tous ces constructeurs, mais encore disputer des choses dans le type de sécurité le plus tôt possible.

    OriginalL'auteur Kevin Wright