contravariance

I am studying variance in scala right now, and I think I have a good understanding of contravariance. For example given trait List[-A] , I know that List[Int] is a supertype of List[AnyVal] . But say that I have the following trait: trait List[+A] { def cons(hd: A): List[A] } Why is cons parameter type wrong? Why it is necessary to have def cons[B >: A](v: B): List[B] ? For example: val animal_list: List[Animal] = List(tiger, dog) if we call: animal_list.cons(tiger) since Tiger <: Animal , doesn't cons ran into problem? Since B is Tiger and A is Animal and B >: A is not true. TeWu Why is cons

It is possible in C# to add variance annotation to type parameter, constrained to be value type: interface IFoo<in T> where T : struct { void Boo(T x); } Why is this allowed by compiler if variance annotation makes completely no sense in a such situation? Why this is allowed by compiler since variance annotation make completely no sense in a such situation? It's allowed by the compiler because I never even considered that someone might try to do that when I added the variance rules to the C# 4.0 compiler. Compiler warnings and errors are features , and in order for a feature to be implemented,

This question already has an answer here: Can’t assign to delegate an anonymous method with less specific parameter type 3 answers The second test method below does not compile (cannot convert lambda expression to target type D1 ). Does that mean that (non-generic) delegate contravariance does not work with lambda expressions? [TestFixture] public class MyVarianceTests { private abstract class Animal {} private class Tiger : Animal {} private delegate Type D1(Tiger tiger); private static Type M1(Animal animal) { return animal.GetType(); } [Test] public void ContravariantDelegateWithMethod() {

abstract class Animal { } class Mammal : Animal { } class Dog : Mammal { } class Reptile : Animal { } class AnimalWrapper<T> where T : Animal { public ISet<AnimalWrapper<T>> Children { get; set; } } class Program { public static void Main(string[] args) { var foo = new AnimalWrapper<Mammal>(); foo.Children = new HashSet<AnimalWrapper<Mammal>>(); var child = new AnimalWrapper<Dog>(); foo.Children.Add(child); } } This obviously doesn't compile because of foo.Children.Add(child); I'm not sure if the above code is the most clear way to demonstrate what I want to do, so I will try to explain in

How can I make the following code work? I don't think I quite understand C# generics. Perhaps, someone can point me in the right direction. public abstract class A { } public class B : A { } public class C : A { } public static List<C> GetCList() { return new List<C>(); } static void Main(string[] args) { List<A> listA = new List<A>(); listA.Add(new B()); listA.Add(new C()); // Compiler cannot implicitly convert List<A> listB = new List<B>(); // Compiler cannot implicitly convert List<A> listC = GetCList(); // However, copying each element is fine // It has something to do with generics (I

I know what covariance and contravariance of types are. My question is why haven't I encountered discussion of these concepts yet in my study of Haskell (as opposed to, say, Scala)? It seems there is a fundamental difference in the way Haskell views types as opposed to Scala or C#, and I'd like to articulate what that difference is. Or maybe I'm wrong and I just haven't learned enough Haskell yet :-) 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

Could someone provide me simple C# examples of convariance, contravariance, invariance and contra-invariance (if such thing exists). All samples I've seen so far was just casting some object into System.Object . Could someone provide me simple C# examples of convariance, contravariance, invariance and contra-invariance (if such thing exists). I have no idea what "contra-invariance" means. The rest are easy. Here's an example of covariance: void FeedTheAnimals(IEnumerable<Animal> animals) { foreach(Animal animal in animals) animal.Feed(); } ... List<Giraffe> giraffes = ...; FeedTheAnimals