Le + dans += sur une carte est-il un opérateur préfixe de = ?

Question

Dans le livre "Programming in Scala" de Martin Odersky, il y a un exemple simple dans le premier chapitre :

var capital = Map("US" -> "Washington", "France" -> "Paris")
capital += ("Japan" -> "Tokyo")

La deuxième ligne peut également être écrite comme suit

capital = capital + ("Japan" -> "Tokyo")

Je suis curieux de connaître la notation +=. Dans la classe Map, je n'ai pas trouvé de méthode +=. J'ai réussi à obtenir le même comportement dans un exemple personnel tel que

class Foo() {
    def +(value:String) = {
        println(value)
        this
    }
}

object Main {
  def main(args: Array[String]) = {
   var foo = new Foo()
   foo = foo + "bar"
   foo += "bar"
  }
}

Je me demande pourquoi la notation += est possible. Elle ne fonctionne pas si la méthode de la classe Foo s'appelle test par exemple. Cela m'a conduit à la notation du préfixe. Le + est-il un préfixe pour le signe d'affectation (=) ? Quelqu'un peut-il expliquer ce comportement ?

Answer 1

Si vous avez une méthode symbolique qui renvoie le même objet, alors l'apposition de equals effectuera l'opération et l'affectation (comme un raccourci pratique pour vous). Vous pouvez également toujours remplacer la méthode symbolique. Par exemple,

scala> class Q { def ~#~(q:Q) = this }
defined class Q

scala> var q = new Q
q: Q = Q@3d511e

scala> q ~#~= q

Answer 2

// Foo.scala
class Foo {
  def +(f: Foo) = this
}

object Foo {
  def main(args: Array[String]) {
    var f = new Foo
    f += f
  }
}

Sortie de scalac -print Foo.scala :

package <empty> {
  class Foo extends java.lang.Object with ScalaObject {
    def +(f: Foo): Foo = this;
    def this(): Foo = {
      Foo.super.this();
      ()
    }
  };
  final class Foo extends java.lang.Object with ScalaObject {
    def main(args: Array[java.lang.String]): Unit = {
      var f: Foo = new Foo();
      f = f.+(f)
    };
    def this(): object Foo = {
      Foo.super.this();
      ()
    }
  }
}

Comme vous pouvez le voir, le compilateur le convertit simplement en une affectation et un appel de la méthode.

Answer 3

+= est un opérateur, où l'implémentation par défaut utilise l'opérateur +. Ainsi, dans la plupart des cas, il fait déjà exactement ce que vous voulez.