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
Instead of creating a brand new type, you can use Ref::map (since Rust 1.8). This has the same result as Levans’ existing answer: use std::cell::Ref; impl Foo { pub fn get_items(&self) -> Ref<‘_, Vec<i32>> { Ref::map(self.interior.borrow(), |mi| &mi.vec) } } You can also use new features like impl Trait to hide the Ref from the … Read more
So what is different between <T> and <in T>? The difference is that in T allows you to pass a more generic (less derived) type than what was specified. And what is the purpose of contravariant here? ReSharper suggests to use contravariance here because it sees the you’re passing the T parameter into the Validate … Read more
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
With <out T>, you can treat the interface reference as one upwards in the hierarchy. With <in T>, you can treat the interface reference as one downwards in the hiearchy. Let me try to explain it in more english terms. Let’s say you are retrieving a list of animals from your zoo, and you intend … 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
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