Typ Folgerung mit existenzieller Art

Question

Ich habe eine generische Eigenschaft SomeTrait definiert als so:

trait SomeTrait[T] { 
    def foo(t: T): String 
} 

und Methoden bar und qux wie so:

def bar[T](t: SomeTrait[T]): T 
def qux: List[SomeTrait[_]] 

Ich habe keine Kontrolle über die oben. Ich versuche, auf der Liste von qux, wie so

qux map { x => x.foo(bar(x))} 

jedoch der Compiler zurück arbeiten beschwert sich, dass die Arten nicht übereinstimmen. Soweit ich weiß, sollte das in Ordnung sein.

Ich habe versucht, eine generische Methode (Signatur [T](SomeTrait[T])String) hinzuzufügen, und das, um die Arbeit zu tun, aber der Compiler beschwert sich noch. Ich kann warf meinen Weg um es so:

qux map { x => 
    val casted = x.asInstanceOf[SomeTrait[T forSome { type T }]] // !!! 
    casted.foo(bar(casted)) 
} 

Aber das ist noch verwirrender, als x bereits den Typ SomeTrait[_] hat und SomeTrait[T forSome { type T }] bedeutet das Gleiche. Der einzige Unterschied, den ich kenne, ist, dass ersterer eine Abkürzung für Letzterer ist, der den Compiler dazu bringt, seine eigenen synthetischen Namen zu erstellen. Ich hoffe, es gibt einen besseren Weg, dies zu tun. Ich habe this question gesehen, aber ich denke nicht, dass es gilt.

Answer 1

Der richtige Weg, dies zu tun, ist eine Variable vom Typ zu verwenden, um einen Namen zu T geben:

qux map { case x: SomeTrait[t] => x.foo(bar(x)) } 

diese Weise kann der Compiler weiß bar(x): t und so ist es ein akzeptables Argument x.foo.

Oder alternativ können Sie foo und bar in ein Verfahren kombinieren (denken Sie daran, dass Methoden lokal sein können, so dass man es nur definieren kann, wo Sie sie brauchen): kompiliert

def fooOfBar[T](x: SomeTrait[T]) = x.foo(bar(x)) 
qux map { fooOfBar(_) }