Implizite ExecutionContext-Priorität in Scala 2.12

Question

In Scala 2.12 importiert den global Ausführungskontext und dann einen anderen impliziten Ausführungskontext im Bereich definiert führt zu einem mehrdeutigen implizit, während in 2.11 es funktioniert gut.

import scala.concurrent._ 
import scala.concurrent.ExecutionContext.Implicits.global 

class A(implicit ec: ExecutionContext) { 
    x = implicitly[ExecutionContext] 
} 

Compiler gibt Fehler:

error: ambiguous implicit values: 
both lazy value global in object Implicits of type => scala.concurrent.ExecutionContext 
and value ec in class A of type scala.concurrent.ExecutionContext 
match expected type scala.concurrent.ExecutionContext 
     val x = implicitly[ExecutionContext] 
         ^

Was ist die Ursache dafür, und wie um es im Code zu arbeiten?

Answer 1

Die Spezifikation behandelt die Überladungsauflösung als Disambiguierung einer Auswahl von Mitgliedern einer Klasse. Aber die implizite Auflösung verwendet die statische Überladungsauflösung, um zwischen Referenzen zu wählen, die keine Mitglieder sind.

Argumentieren, die folgende ist eine Fehlinterpretation der Spezifikation, da zzz in einer Klasse von X viel wie yyy abgeleitet definiert ist:

$ scala 
Welcome to Scala 2.12.0 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_101). 
Type in expressions for evaluation. Or try :help. 

scala> import concurrent._, ExecutionContext.global 
import concurrent._ 
import ExecutionContext.global 

scala> trait X { implicit val xxx: ExecutionContext = global } 
defined trait X 

scala> class Y extends X { implicit val yyy: ExecutionContext = global ; def f = implicitly[ExecutionContext] } 
defined class Y 

scala> class Z extends X { def f(implicit zzz: ExecutionContext) = implicitly[ExecutionContext] } 
<console>:16: error: ambiguous implicit values: 
both value xxx in trait X of type => scala.concurrent.ExecutionContext 
and value zzz of type scala.concurrent.ExecutionContext 
match expected type scala.concurrent.ExecutionContext 
     class Z extends X { def f(implicit zzz: ExecutionContext) = implicitly[ExecutionContext] } 
                      ^

Derzeit müssen Sie auf die Benennung verlassen, um die impliziten von umschließenden beschatten Umfang:

scala> class Z extends X { def f(implicit xxx: ExecutionContext) = implicitly[ExecutionContext] } 
defined class Z 

Oder

scala> :pa 
// Entering paste mode (ctrl-D to finish) 

package object p { import concurrent._ ; implicit val xxx: ExecutionContext = ExecutionContext.global } 
package p { import concurrent._ ; 
    class P { def f(implicit xxx: ExecutionContext) = implicitly[ExecutionContext] 
      def g = implicitly[ExecutionContext] } 
} 

// Exiting paste mode, now interpreting. 


scala>