Strukturelle Verfeinerung und Typgleichheit

Question

Ich stolperte über ein rätselhaftes Verhalten von Type.=:=, wenn es auf Typreparaturen angewendet wurde. Bedenken Sie:

import reflect.runtime.universe._ 
type T1 = AnyRef { 
    def apply(name: String): Unit 
    def foo: String 
} 

type Base = { def apply(name: String): Unit } 
type T2 = Base { 
    def foo: String 
} 

Da Base ist ein Alias ​​für eine Art Verfeinerung, würde ich erwarten, dass die Verfeinerung es weiter durch das Element Zugabe foo würde die gleiche Art ergeben, wie wenn ich foo rechts in Base definiert hatte.

Oder mit anderen Worten, ich würde erwarten, dass T1 und T2 völlig äquivalente Typen bezeichnen.

In den meisten Fällen scheint scalac zuzustimmen. Mit dem Beispiel ich eine Instanz von T2 passieren kann, wenn eine Instanz von T1 erwartet wird:

def f(x: T1){} 
f(null: T2) // scalac does not complain here 

Und umgekehrt:

def g(x: T2){} 
g(null: T1) // scalac is still happy 

ich auch für einen Beweis stellen kann T1 =:= T2 und kompiliert es auch in Ordnung:

implicitly[T1 =:= T2] 

jedoch, scala Reflexion ich mit ge t ganz andere Ergebnisse:

scala> typeOf[T1] =:= typeOf[T2] 
res2: Boolean = false 

Das ist also ein scala Reflexion Fehler (ich würde vermuten, so) oder ist es ein wesentlicher Grund (technisch von anderen Gründen), warum typeOf[T1] =:= typeOf[T2] würde false zurück?

Answer 1

Leider sieht es dieser Fehler zu sein: https://issues.scala-lang.org/browse/SI-8177

Auf der positiven Seite ... es sieht aus wie es gibt Arbeit aktiv im Gange, es zu beheben :)