Scala: applicazione di vista

Question

Ecco un breve codice:

import scala.language.implicitConversions 

implicit def str2int(str:String) = str.toInt 

object Container { 
    def addIt[A](x: A)(implicit str2int: A => Int) = 123 + x 
    def addIt2(x: String)(implicit str2int: String => Int) = 123 + x 
} 

println(Container.addIt("123")); 
println(Container.addIt2("123")); 

Due domande:

1. è "(implicita str2int: A => Int)" chiamato un punto di vista? Quando dici una "vista", quale parte specifica del codice indica?
2. Perché addIt restituisce 246 mentre addIt2 restituisce una stringa "123123"?

Qualsiasi buona risorsa su questo argomento sarebbe anche molto apprezzata. Grazie.

Answer 1

Vista significa che un tipo A può essere "visualizzato" come tipo B, specificato da una funzione implicita A => B. Quindi, sì, entrambi gli argomenti impliciti in addIt e addIt2 sono visualizzazioni.

addIt2 rendimenti 123123 perché è (purtroppo) possibile chiamare + su due oggetti in cui uno di loro è un String. Questo comando viene eseguito prima che Scala analizzi la possibilità di applicare la conversione str2int. Se non si desidera che, è possibile applicare in modo esplicito la vista:

def addIt2(x: String)(implicit str2int: String => Int) = 123 + str2int(x) 

Oppure si può nascondere la conversione any2stringadd:

object Container { 
    import Predef.{any2stringadd => _} 
    def addIt2(x: String)(implicit str2int: String => Int) = 123 + x 
} 

Answer 2

1. Sì, è una vista implicita, ma doesn 't indicare qualsiasi parte specifica del codice. Dice solo che il tipo A dovrebbe essere 'convertibile', preferibilmente implicitamente nel tipo Int, per es. il convertitore implicito dovrebbe essere incluso nell'ambito di questo metodo.

2. Sembra che quando il compilatore traduce il primo metodo vede 123. + (X: A) e cerca di trovare implicito per il tipo A che "+" compila.

Nel secondo caso, tuttavia, vede 123. + (X: String) e c'è una conversione implicita in Scala Predef. È in effetti una stranezza nell'implementazione di Scala. La dichiarazione implicita è:

final class StringAdd(self: Any) { 
    def +(other: String) = self.toString + other 
} 

è stato lasciato a Scala per la convenienza di ex sviluppatori Java che vengono utilizzati per sintassi del tipo: 123 + "something" e si aspettano di essere una stringa.