Wirkliches Beispiel von "Können alle Verwendungen von` forSome 'durch eine äquivalente Verwendung von `_` ersetzt werden?"

Question

Ich sah die Antwort auf die Frage: Can all usages of forSome be replaced by an equivalent usage of _?, aber nicht verstehen, was ist der echte Fall, wo "_" kann nicht anstelle von "forSome" verwendet werden. Ich lese in Programming in Scala Buch, dass:

Existentielle Typen ein vollständig unterstützter Teil der Sprache, aber in der Praxis sie werden hauptsächlich verwendet, wenn Java-Typen von Scala erreichbar. habe ich Scala-Projekt und Java ein, um diese Seite verwiesen:

Scala:

object Main { 
    def main(args: Array[String]): Unit = { 
    type Test = java.util.Collection[T] forSome { type T } 
    val contents: Test = (new Wild).contents 

    type Test2 = java.util.Collection[_] 
    val contents2: Test2 = (new Wild).contents 

    // foo((new Wild).contents2) // won't compile 

    foo1((new Wild).contents2) 
    foo1((new Wild).contents3) 

    foo2((new Wild).contents3) 
    } 

    def foo(xs: java.util.Map[T, T] forSome { type T }) {} 
    def foo1(xs: java.util.Map[_, _]) {} 
    def foo2(xs: java.util.Map[_, _ <: java.lang.Number]) {} 
} 

Java:

public class Wild { 
    public Collection<?> contents() { 
     return null; 
    } 
    public Map<?, ?> contents2() { 
     return null; 
    } 
    public Map<?, ? extends Number> contents3() { 
     return null; 
    } 
} 

In allen Fällen konnte ich "forsome" mit „ersetzen _ ". Was sind also echte Fälle, in denen "forSome" notwendig ist? Bitte geben Sie ein einfaches Arbeitsbeispiel an.

Answer 1

Hier ist ein ziemlich einfaches Beispiel.

val listOfSets: List[Set[T]] forSome { type T } = List(Set(1, 2, 3), Set(4, 5, 6)) 

Bitte beachte, dass ich nur in der Lage bin Sätze des gleichen enthaltenen Typs in die Liste zu speichern. Ich kann z.B. dies:

val listOfSets: List[Set[T]] forSome { type T } = List(Set(1, 2, 3), Set("a", "b", "c")) 

Die Art der listOfSets ist inexpressable ohne forSome. Tatsächlich

val listOfSets2: List[Set[_]] 

entspricht

val listOfSets2: List[Set[T] forSome { type T }] 

und dies bedeutet, dass die Liste Sätze von verschiedenen Typen enthalten, so dass beide dieser Arbeit:

val listOfSets2: List[Set[_]] = List(Set(1, 2, 3), Set(4, 5, 6)) 
val listOfSets2: List[Set[_]] = List(Set(1, 2, 3), Set("a", "b", "c")) 

Es ist interessant, Wenn Sie Scala-Interpreter als scala -feature ausführen und versuchen, die allererste Codezeile aus dieser Antwort auszuführen, erhalten Sie eine Warnung genau über i nexpressability existentieller Art mit Wildcards:

scala> val listOfSets: List[Set[T]] forSome { type T } = List(Set(1, 2, 3), Set(4, 5, 6)) 
<console>:7: warning: the existential type List[Set[T]] forSome { type T }, which cannot be expressed by wildcards, should be enabled 
by making the implicit value scala.language.existentials visible. 
This can be achieved by adding the import clause 'import scala.language.existentials' 
or by setting the compiler option -language:existentials. 
See the Scala docs for value scala.language.existentials for a discussion 
why the feature should be explicitly enabled. 
     val listOfSets: List[Set[T]] forSome { type T } = List(Set(1, 2, 3), Set(4, 5, 6)) 
            ^
listOfSets: List[Set[T]] forSome { type T } = List(Set(1, 2, 3), Set(4, 5, 6)) 

---

Es ist ein weiteres Beispiel. Angenommen, Sie möchten eine Klasse einer einzelnen Instanz dieser Klasse zuordnen. Dies kann mit dieser Art ausgedrückt werden:

val classInstanceMap: Map[Class[T], T] forSome { type T } 

Ohne forSome Sie den richtigen Typen aus nicht schreiben können - es gibt keine andere Möglichkeit ist es, „bezieht“ Arten von Schlüsseln und Werten.Zum Beispiel diese Art mit Wildcards:

val invalidClassInstanceMap: Map[Class[_], _] 

äquivalent zu

val invalidClassInstanceMap: Map[Class[K] forSome { type K }, V] forSome { type V } 

Hier K und V überhaupt nicht im Zusammenhang, können darüber hinaus Tasten beliebige Instanzen Class[T] sein für beliebige T, aber alle Werte sollten den gleichen Typ haben.