Eindeutiges Subimplicits

Question

Betrachten Sie den folgenden Code ein:

class A { def print = println("A") } 
class B extends A { override def print = println("B") } 

def foo(implicit a: A) = a.print 

def bar(implicit a: A) = { 
    implicit val b = new B 
    foo 
} 

bar(new A) // B 

Ich frage mich, warum ruft foo in bar ist kein ambiguous implicit values Fehler zu erhöhen. Natürlich

implicit val b: A = new B 

wird diesen Fehler erhöhen. Warum wählt foo das implizite b und nicht das implizite a? Oder noch allgemeiner: Was sind die Regeln, die ausgewählt werden?

EDIT:
Aufgrund meines Kommentars-Gespräch mit Ivan ich klarstellen möchte: Ich würde die Antwort auf meine Frage, ob ich die lokale implizite val die gleiche Art und Weise wie die implizite Methodenparameter genannt.

def bar(implicit a: A) = { 
    implicit val a = new B 
    foo 
} 

Dann nur die lokale val a ist in ihrem Umfang, die den Methodenparameter Anwendungsbereich-Vorrang, weil sie den gleichen Namen haben.

Answer 1

Hinweis: Ich übertreibe wahrscheinlich Dinge sehr, aber beim Testen schien es wie folgt.

Es ist, weil der zweite in einem inneren Bereich ist, also hat es Vorrang. Es ist die gleiche Sache, die mit

object test { 
val a = 5 
def test(i: Int) = { 
    val a = 6 
    i + a 
} 
} 

In diesem Fall passiert, würden Sie a erwarten 6 innerhalb der Funktion zu sein. Das Folgende ist ähnlich.

object test { 
    implicit val i = 5; 
    { 
    implicit val b = 6; 
    test 
    } 
    def test(implicit ii:Int) = println(ii) 
} 

Aktualisiert von Kommentar.

scala> def test(a: Int) = {val a = 5; a } 
test: (a: Int)Int 

scala> test(6) 
res1: Int = 5