Betrachten Sie den Unterschied zwischen den folgenden zwei Ausdrücken:
%Vor%Und:
%Vor% Denken Sie nun darüber nach, wie der Typparameter T von valueOf in jedem dieser Fälle abgeleitet wird. Im ersten Fall haben wir ein X , von dem wir wissen, dass es ein Untertyp von Enum[X] ist, und wir sind fertig. Im zweiten Fall müsste andererseits T X forSome { type X <: Enum[X] } sein, und im Wesentlichen ist dieser Typ kein Subtyp von Enum[X forSome { type X <: Enum[X] }] , sodass wir die Bedingung für T nicht erfüllt haben.
Das Problem ist, dass Ihr zweites Beispiel dem letzteren entspricht.
Als Fußnote würde das gut funktionieren, wenn Enum in seinem Typparameter kovariant wäre. Nehmen Sie das folgende vereinfachte Beispiel:
Jetzt wird foo(x) kompilieren, aber foo(y) wird nicht, genau wie in deinem Code. Aber ändere Bar ein bisschen:
Jetzt werden sie beide kompilieren. Ich vermute, dass dies etwas damit zu tun hat, dass wir so starke Intuitionen haben, dass Ihre beiden Beispiele gleichwertig sind.
Als weitere Fußnote (als Antwort auf gzmo ist Kommentar unten ), beachten Sie Folgendes:
%Vor% Nehmen wir an, dass X forSome { type X <: Foo[X] } ein Untertyp von Foo[X forSome { type X <: Foo[X] }] ist (ignoriere für einen Moment, dass letzterer nicht einmal ein gültiger Typ ist). Dann könnten wir folgendes schreiben:
Aber Foo ist invariant. Wenn wir also etwas haben, das eine Instanz von Foo[A] und Foo[B] ist, dann muss A =:= B sein. Aber es ist definitiv nicht so, dass MyFoo =:= (X forSome { type X <: Foo[X] }) . Nicht sicher, all das ist nicht weniger verwirrend, aber ich habe mich davon überzeugt, dass der Compiler weiß, was er hier macht.