è il + in + = su una mappa un operatore prefisso di =?

Question

Nel libro "Programming in Scala" da Martin Odersky c'è un semplice esempio nel primo capitolo:

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

La seconda linea può anche essere scritta come

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

Io sono curioso circa la + = notazione. Nella mappa di classe, non ho trovato un metodo + =. Ho potuto lo stesso comportamento in una propria esempio come

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

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

mi metto in discussione, perché il + = notazione è possibile. Ad esempio, non funziona se il metodo nella classe Foo è chiamato test. Questo mi ha portato alla notazione prefisso. + La notazione del prefisso per il segno di assegnazione (=)? Qualcuno può spiegare questo comportamento?

Answer 1

Se si dispone di un metodo simbolico che restituisce lo stesso oggetto, quindi l'aggiunta di uguali eseguirà l'operazione e l'assegnazione (come una scorciatoia utile per te). Puoi sempre sostituire il metodo simbolico. Ad esempio,

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

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

scala> q ~#~= q 

Answer 2

+ = è un operatore, in cui l'implementazione predefinita utilizza l'operatore +. Quindi, nella maggior parte dei casi, fa già esattamente quello che vuoi.

Answer 3

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

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

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

Come si può vedere il compilatore converte semplicemente ad un incarico e una chiamata del metodo.