In Guava, warum wird nur "T" verwendet, wo "Super T" möglich wäre?

Question

Warum verwenden die Factory-Factory-Methoden häufig einen spezifischen generischen Parameter (wie T) anstelle eines beschränkten Wildcard-Parameters (wie ? super T)?

Zum Beispiel die Unterschrift von Functions#forPredicate ist:

public static <T> Function<T, Boolean> forPredicate(Predicate<T> predicate) 

Warum nicht:

public static <T> Function<T, Boolean> forPredicate(Predicate<? super T> predicate) 

Welche wäre so etwas wie die folgenden möglich machen?

Predicate<Number> isPositivePredicate = ... 
Function<Integer, Boolean> isPositiveInteger = Functions.forPredicate(isPositivePredicate); 
// above line is compiler error: 
// Type mismatch: cannot convert from Function<Number,Boolean> to Function<Integer,Boolean> 

Ist es, weil Verbraucher von Function und Predicate zu erwarten sind, die notwendigen beschränkten Wildcard Parameter haben, um diese überflüssig zu machen? Zum Beispiel würden die allgemeinen Grenzen für Iterables#find erlauben eine Predicate<Number> zu auf einem Iterable<Integer> verwendet werden:

public static <T> T find(Iterable<T> iterable, 
         Predicate<? super T> predicate) 

Gibt es andere Gründe?

Answer 1

Ja, es ist absolut richtig, dass wir die Verbraucher erwarten, dass das Recht begrenzt Wildcard-Parameter haben, aber ein paar weitere Gründe in den Sinn:

• Im Allgemeinen haben wir nicht die Typen von generischen Methoden erweitern bis wir einen bestimmten Grund haben. Diese Politik hat sich mehrfach ausgezahlt.
• Java-Typ-Inferenz ist nicht immer in der Lage, erweiterte Generika automatisch herauszufinden, so dass die schmaleren Generika zu halten reduziert die Anzahl der Benutzer, die explizit angeben müssen T.

Answer 2

Im find() Beispiel kann immer eindeutig auf T gefolgert werden.

In dem Beispiel forPredicate[1]() kann T auch eindeutig abgeleitet werden. Im forPredicate[2]() Beispiel gibt es Unsicherheit, was T sein sollte. Wenn das Ergebnis der Methode einem Zieltyp zugeordnet ist, kann aus dem Zieltyp T ermittelt werden. Sonst ist es ein wenig Kopf kratzen:

forPredicate(isPositive).apply(42); // T is a subtype of Number, but which one? 

In Java5/6 sollte es nicht kompilieren. (Gut Getestet habe ich es auf Java 6 und es läßt sich, aber es ist wahrscheinlich ein Fehler, da auch Java 6 kompiliert forPredicate(p).apply("str"))

Java 7 ein wenig verbessert, und die neue Regel vor, dass T=Number zu diktieren. Es funktioniert, aber es fühlt sich eher wie ein Schiedsgericht an.

---

Idealerweise sollten wir uns keine Gedanken über Platzhalter machen. Wenn ich ein Prädikat für meine Ganzzahlen benötige, sollte ich einen Predicate<Integer> Parameter deklarieren. Die Tatsache, dass ein Predicate<Number> Argument auch akzeptabel wäre, ist eine andere Geschichte. Es sollte die Aufgabe des Compilers sein, Predicate<Number> in Predicate<Integer> umzuwandeln - wir können es tun, ohne existierende Java-Generika zu überholen, eine neue Konvertierungsregel ist alles, was benötigt wird.Man kann auch eine Umwandlung Bibliothek

Predicate<Number> pn = ...; 
Predicate<Integer> pi = convert(pn); 

Iterable<Integer> iter1 = ...; 
Iterable<Number> iter2 = convert(iter1); 

Alle convert() Methoden mechanisch erzeugt werden kann.

---

Java 8 machen die Dinge ein wenig einfacher. Wir können immer noch nicht tun

Predicate<Number> pn = n -> n.intValue()>0; 
Predicate<Integer> pi = pn; // error! 

aber wir können

Predicate<Integer> pi = pn::test; // ok 
// it means  pi = (Integer i)->pn.test(i) 

auch

Function<Integer, Boolean> f = pn::test; // ok 

tun, was f = forPredicate[2](pn) entspricht. In Java 8 brauchen wir selten forPredicate() usw., um zwischen Funktionstypen zu konvertieren.