Was ist daran falsch (Compilerfehler)?

Question

Es tut mir leid für solche nicht beschreibenden Titel, aber ich weiß wirklich nicht, wie man das besser ausdrücken kann.

class Foo[T] 
Seq(new Foo[String], new Foo[Int]).groupBy(_ => 1).map { case (k, Seq(v)) => k -> v }.toMap 
<console>:12: error: Cannot prove that (Int, Foo[_146]) forSome { type _146 >: Int with String } <:< (T, U). 

WTF? Wenn ich .mapValues anstelle von .map verwende, funktioniert es. Auch macht es Foo kovariant behebt es auch, aber in diesem Fall am Ende mit Map[Int,Foo[Any]] Was ist hier los? Irgendwelche Ideen?

Answer 1

Ohne Varianz Sie eine etwas „unsinnig“ -Sequenz erstellen:

class Foo[T] 
val in = Seq(new Foo[String], new Foo[Int]) // Seq[_ >: Int with String]] 

Es gibt einfach keine gemeinsame LUB zwischen Foo[String] und Foo[Int] ist. Sie können es eine existenzielle Art zuordnen:

val in = Seq[Foo[_]](new Foo[String], new Foo[Int]) 

Dann können wir weiterhin versuchen:

val in = Seq[Foo[_]](new Foo[String], new Foo[Int]) 
val g = in.groupBy(_ => 1) // Map[Int, Seq[Foo[_]]] 
// the next line would produce a match error, thus make it a `def` 
def m = g.map { case (k, Seq(v)) => k -> v } // Iterable[(Int, Foo[_])] 
def p = m.toMap // cannot prove that (Int, Foo[_]) <:< (T, U) 

Wieder ist die existenzielle Art beißt man hier in eine nützliche Folgerung für den Werttyp disallowing. Sie können es erneut erzwingen:

def p = m.toMap[Int, Foo[_]] // Map[Int,Foo[_]] 

AFAIK, Scalac wird keine existentiellen Typen für Sie ableiten.

---

Wenn Sie denken, Sie Foo[Any] hier haben, müssen Sie eine Varianz Anmerkung hinzuzufügen:

class Foo[+T] 
val in = Seq(new Foo[String], new Foo[Int]) // Seq[Foo[Any]] 
def m = in.groupBy(_=>1).map {case (k,Seq(v)) => k->v}.toMap // Map[Int,Foo[Any]]