UPDATE: This answer was written in 2011. After two decades of people proposing return type covariance for C# they have been implemented. See Covariant Returns in https://devblogs.microsoft.com/dotnet/c-9-0-on-the-record/. It sounds like what you want is return type covariance. C# does not support return type covariance. Return type covariance is where you override a base class method … Read more
Set is invariant in its type parameter because of the concept behind sets as functions. The following signatures should clarify things slightly: trait Set[A] extends (A=>Boolean) { def apply(e: A): Boolean } If Set were covariant in A, the apply method would be unable to take a parameter of type A due to the contravariance … Read more
Variance will only be supported in a safe way – in fact, using the abilities that the CLR already has. So the examples I give in the book of trying to use a List<Banana> as a List<Fruit> (or whatever it was) still won’t work – but a few other scenarios will. Firstly, it will only … Read more
Covariance: class Super { Object getSomething(){} } class Sub extends Super { String getSomething() {} } Sub#getSomething is covariant because it returns a subclass of the return type of Super#getSomething (but fullfills the contract of Super.getSomething()) Contravariance class Super{ void doSomething(String parameter) } class Sub extends Super{ void doSomething(Object parameter) } Sub#doSomething is contravariant because … Read more
The error message is insufficiently informative, and that is my fault. Sorry about that. The problem you are experiencing is a consequence of the fact that covariance only works on reference types. You’re probably saying “but IA is a reference type” right now. Yes, it is. But you didn’t say that T is equal to … Read more
Covariant return, means that when one overrides a method, the return type of the overriding method is allowed to be a subtype of the overridden method’s return type. To clarify this with an example, a common case is Object.clone() – which is declared to return a type of Object. You could override this in your … Read more
Generically, a covariant type parameter is one which is allowed to vary down as the class is subtyped (alternatively, vary with subtyping, hence the “co-” prefix). More concretely: trait List[+A] List[Int] is a subtype of List[AnyVal] because Int is a subtype of AnyVal. This means that you may provide an instance of List[Int] when a … Read more
Some say it is about relationship between types and subtypes, other say it is about type conversion and others say it is used to decide whether a method is overwritten or overloaded. All of the above. At heart, these terms describe how the subtype relation is affected by type transformations. That is, if A and … Read more
What it means is this Control[] controls = new LinkLabel[10]; // compile time legal controls[0] = new TextBox(); // compile time legal, runtime exception And in more general terms string[] array = new string[10]; object[] objs = array; // legal at compile time objs[0] = new Foo(); // again legal, with runtime exception In C#, … Read more
Basically, variance applies when the CLR can ensure that it doesn’t need to make any representational change to the values. References all look the same – so you can use an IEnumerable<string> as an IEnumerable<object> without any change in representation; the native code itself doesn’t need to know what you’re doing with the values at … Read more