List<Dog> is a subtype of List<? extends Animal>, but not a subtype of List<Animal>. Why is List<Dog> not a subtype of List<Animal>? Consider the following example: void mySub(List<Animal> myList) { myList.add(new Cat()); } If you were allowed to pass a List<Dog> to this function, you would get a run-time error. EDIT: Now, if we use … Read more
Update: from .NET 4.5 onwards there is IReadOnlyList<out T> and IReadOnlyCollection<out T> which are both covariant; The latter is basically IEnumerable<out T> plus Count; the former adds T this[int index] {get;}. It should also be noted that IEnumerable<out T> is covariant from .NET 4.0 onwards. Both List<T> and ReadOnlyCollection<T> (via List<T>.AsReadOnly()) implement both of these. … Read more
Is C# type system decidable? A type system is “decidable” if the compiler is in theory always able to decide whether the program type checks or not in finite time. The C# type system is not decidable. C# has “nominal” subtyping — that is, you give classes and interfaces names and say what the base … Read more
Because it would break type-safety otherwise. If not, you would be able to do something like this: val arr:Array[Int] = Array[Int](1,2,3) val arr2:Array[Any] = arr arr2(0) = 2.54 and the compiler can’t catch it. On the other hand, lists are immutable, so you can’t add something that is not Int
There are two main reasons: Haskell lacks an inherent notion of subtyping, so in general variance is less relevant. Contravariance mostly appears where mutability is involved, so most data types in Haskell would simply be covariant and there’d be little value to distinguishing that explicitly. However, the concepts do apply–for instance, the lifting operation performed … Read more
Now, to my untrained eye, covariance seems to be the same as upcasting, except that it refers the casting of collections. (And of a similar statement can be made regarding contravariance and downcasting). Is it really that simple? Covariance isn’t about upcasting, although I can see why you think it’s related. Covariance is about the … Read more
It’s a feature. .NET 4.0 only supports safe covariance. The cast you mentioned is potentially dangerous as you could add a non-string element to the dictionary if that was possible: IDictionary<string, object> myDict = new Dictionary<string, string>(); myDict[“hello”] = 5; // not an string On the other hand, IEnumerable<T> is a read-only interface. The T … Read more
I had to think long and hard on how to explain this well. Explaining is seems to be just as hard as understanding it. Imagine you have a base class Fruit. And you have two subclasses Apple and Banana. Fruit / \ Banana Apple You create two objects: Apple a = new Apple(); Banana b … Read more
Well this certainly won’t be supported in C# 4. There’s a fundamental problem: List<Giraffe> giraffes = new List<Giraffe>(); giraffes.Add(new Giraffe()); List<Animal> animals = giraffes; animals.Add(new Lion()); // Aargh! Keep giraffes safe: just say no to unsafe variance. The array version works because arrays do support reference type variance, with execution time checking. The point of … Read more
A generic method of Task.WaitAll would imply that all Tasks would have to return the same type which would be extremely limited usefulness. Writting something like that could be done manually (see Bas Brekelmans answer), but this wont allow ContinueWith or cancellation without alot of work. A simple solution if you aren’t using the array … Read more