Re: [RFC:generics]

guilhermeblanco@gmail.com wrote on 29/04/2016 15:26:

You can add subtypes of A to a List<A> in Java. What List<? extends A>

means is that the list itself may be a list of any type, provided that type is compatible with A. So if B extends A, List<B> is compatible with List<? extends A>, and when reading items you can assume they will be compatible with A (since B extends A) but you can't add an A (because it's actually a list of Bs). Wrong. This is documented here https://docs.oracle.com/javase/tutorial/java/generics/upperBounded.html and specifically states: To write the method that works on lists of Number and the subtypes of Number, such as Integer, Double, and Float, you would specify List<? extends Number>. The term List<Number> is more restrictive than List<? extends Number> because the former matches a list of type Number only, whereas the latter matches a list of type Number or any of its subclasses.

Forgive me for butting in if I'm completely wrong, but is the confusion here between *declaring an instance* and *declaring a parameter constraint*? I think the point is that you can declare variables as follows: List<Integer> li; // only accepts Integer List<Double> ld; // only accepts Double List<Number> ln; // accepts any Number, even if it is in fact an Integer or Double instance But if you then define a function accepting a parameter: public static double sumOfList(List<Number> list) Now your argument has to be of type List<Number>; you can pass "ln" above, but not "li" or "ld". To relax the function's contract, you can write this instead: public static double sumOfList(List<? extends Number> list) Now the argument can be a List<Integer> or List<Double>, so "li" and "ld" are legal arguments. The reason the default case is to be invariant, rather than covariant, is explained on the blog post Jesse linked to: http://hhvm.com/blog/9215/covariance-contravariance-and-super-type-constraints In a nutshell, consider this function: function addPiToList(List<Number> $list): void { $list->add(3.1415); // for the sake of example, assume 3.1415 instanceOf Double } If we allow covariance, then we can run addPiToList(new List<Integer>) and the type conditions are met; clearly this is not sane, and is going to result in an error somewhere. So we need to be stricter: function addPiToList(List<Double> $list): void But the actual contract we want here is "any list we can legally add a Double to", and if we get a List<Number> or a List<*>, it would work fine, so our check is too strict. What's needed is a way to declare our function as contravariant: function addPiToList(List<? super Double> $list): void Now we can pass in a List<Double> or a List<Number>, but not a List<Integer>, and our contract holds nicely. It took me a while to get my head around, but I think the above makes sense... Regards, -- Rowan Collins [IMSoP]