es el + en + = en un operador de prefijo Map of =?

Question

En el libro "Programación en Scala" de Martin Odersky hay un ejemplo sencillo en el primer capítulo:

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

La segunda línea también se puede escribir como

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

tengo curiosidad acerca de la + = notación. En el mapa de clase, no encontré un método + =. Pude el mismo comportamiento en un propio ejemplo como

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

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

estoy cuestionando a mí mismo, ¿por qué el + = notación es posible. No funciona si el método en la clase Foo se llama prueba por ejemplo. Esto me lleva a la notación de prefijo. ¿Es la notación de prefijo + a para el signo de asignación (=)? ¿Alguien puede explicar este comportamiento?

Answer 1

Si tiene un método simbólico que devuelve el mismo objeto, la adición de iguales realizará la operación y la asignación (como un atajo útil para usted). También puede anular siempre el método simbólico. Por ejemplo,

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

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

scala> q ~#~= q 

Answer 2

+ = es un operador, donde la implementación predeterminada usa el operador +. Entonces, en la mayoría de los casos, ya hace exactamente lo que quiere.

Answer 3

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

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

salida 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(); 
    () 
    } 
    } 
} 

Como se puede ver el compilador simplemente la convierte en una tarea y una llamada del método.