What is the difference between `&lt;out T&gt;` and `&lt;T&gt;`? For example:

    public interface IExample&lt;out T&gt;
    {
        ...
    }
vs.

    public interface IExample&lt;T&gt;
    {
        ...
    }

&lt;out T&gt; vs &lt;T&gt; in Generics

While we can inherit from base class/interface, why can&#39;t we declare a `List&lt;&gt;`
using same class/interface?   

    interface A
    { }

    class B : A
    { }

    class C : B
    { }

    class Test
    {
        static void Main(string[] args)
        {
            A a = new C(); // OK
            List&lt;A&gt; listOfA = new List&lt;C&gt;(); // compiler Error
        }
    }

Is there a way around?

Convert List&lt;DerivedClass&gt; to List&lt;BaseClass&gt;

From Effective Java by Joshua Bloch,

1. Arrays differ from generic type in two important ways. First arrays are covariant. Generics are invariant.
2. Covariant simply means if X is subtype of Y then X[] will also be sub type of Y[]. Arrays are covariant As string is subtype of Object So

    `String[] is subtype of Object[]`

     Invariant simply means irrespective of X being subtype of Y or not ,

         List&lt;X&gt; will not be subType of List&lt;Y&gt;.

My question is why the decision to make arrays covariant in Java? There are other SO posts such as https://stackoverflow.com/questions/6684493/why-are-arrays-invariant-but-lists-covariant, but they seem to be focussed on Scala and I am not able to follow.

Why are arrays covariant but generics are invariant?

I&#39;m having a little trouble understanding how I would use covariance and contravariance in the real world.

So far, the only examples I&#39;ve seen have been the same old array example.

    object[] objectArray = new string[] { &quot;string 1&quot;, &quot;string 2&quot; };


It would be nice to see an example that would allow me to use it during my development if I could see it being used elsewhere.


Covariance and contravariance real world example

I am having trouble understanding the difference between covariance and contravariance. 




Difference between Covariance &amp; Contra-variance

`IEnumerable&lt;T&gt;` is *co-variant* but it does not support value type, just only reference type. The below simple code is compiled successfully:

    IEnumerable&lt;string&gt; strList = new List&lt;string&gt;();
    IEnumerable&lt;object&gt; objList = strList;

But changing from `string` to `int` will get compiled error:

    IEnumerable&lt;int&gt; intList = new List&lt;int&gt;();
    IEnumerable&lt;object&gt; objList = intList;

The reason is explained in [MSDN][1]:

&gt;Variance applies only to reference types; if you specify a value type for a variant type parameter, that type parameter is invariant for the resulting constructed type.

I have searched and found that some questions mentioned the reason is *boxing between value type and reference type*. But it does not still clear up my mind much why boxing is the reason?

Could someone please give a simple and detailed explanation why covariance and contravariance do not support value type and how *boxing* affects this?


  [1]: http://msdn.microsoft.com/en-us/library/dd799517.aspx#InterfaceCovariantTypeParameters

Why covariance and contravariance do not support value type

I have a `private readonly` list of `LinkLabel`s (`IList&lt;LinkLabel&gt;`). I later add `LinkLabel`s to this list and add those labels to a `FlowLayoutPanel` like follows:


    foreach(var s in strings)
    {
        _list.Add(new LinkLabel{Text=s});
    }

    flPanel.Controls.AddRange(_list.ToArray());

Resharper shows me a warning: `Co-variant array conversion from LinkLabel[] to Control[] can cause run-time exception on write operation`. 

Please help me to figure out:

  1. What does this means? 
  2. This is a user control and will not be accessed by multiple objects to setup labels,
     so keeping code as such will not affect it.


Co-variant array conversion from x to y may cause run-time exception

Following on from [this question][1], can someone explain the following in Scala:

    class Slot[+T] (var some: T) { 
       //  DOES NOT COMPILE 
       //  &quot;COVARIANT parameter in CONTRAVARIANT position&quot;

    }

I understand the distinction between **`+T`** and **`T`** in the type declaration (it compiles if I use **`T`**). But then how does one actually write a class which is covariant in its type parameter without resorting to creating the thing *unparametrized*? How can I ensure that the following can only be created with an instance of **`T`**?

    class Slot[+T] (var some: Object){    
      def get() = { some.asInstanceOf[T] }
    }

**EDIT** - now got this down to the following:

    abstract class _Slot[+T, V &lt;: T] (var some: V) {
        def getT() = { some }
    }

this is all good, but I now have two type parameters, where I only want one. I&#39;ll re-ask the question thus:

**How can I write an *immutable* `Slot` class which is *covariant* in its type?**

**EDIT 2**: Duh! I used `var` and not `val`. The following is what I wanted:
    
    class Slot[+T] (val some: T) { 
    }

  [1]: https://stackoverflow.com/questions/663032/generic-wildcards-in-variable-declarations-in-scala

Why doesn&#39;t the example compile, aka how does (co-, contra-, and in-) variance work?

Today, I read some articles about Covariance, Contravariance (and Invariance) in Java. I read the English and German Wikipedia article, and some other blog posts and articles from IBM.

But I&#39;m still a little bit confused on what these exactly are about? Some say it&#39;s about relationship between types and subtypes, some say it&#39;s about type conversion and some say it&#39;s used to decide whether a method is overridden or overloaded.

So I&#39;m looking for an easy explanation in plain English, that shows a beginner what Covariance and Contravariance (and Invariance) is. Plus point for an easy example.

Covariance, Invariance and Contravariance explained in plain English?

What is a covariant return type in Java?  In object-oriented programming in general?

What is a covariant return type?

I can&#39;t understand why the following C# code doesn&#39;t compile.

As you can see, I have a static generic method Something with an `IEnumerable&lt;T&gt;` parameter (and `T` is constrained to be an `IA` interface), and this parameter can&#39;t be implicitly converted to `IEnumerable&lt;IA&gt;`.

What is the explanation? (I don&#39;t search for a workaround, just to understand why it doesn&#39;t work).

    public interface IA { }
    public interface IB : IA { }
    public class CIA : IA { }
    public class CIAD : CIA { }
    public class CIB : IB { }
    public class CIBD : CIB { }

    public static class Test
    {
        public static IList&lt;T&gt; Something&lt;T&gt;(IEnumerable&lt;T&gt; foo) where T : IA
        {
            var bar = foo.ToList();

            // All those calls are legal
            Something2(new List&lt;IA&gt;());
            Something2(new List&lt;IB&gt;());
            Something2(new List&lt;CIA&gt;());
            Something2(new List&lt;CIAD&gt;());
            Something2(new List&lt;CIB&gt;());
            Something2(new List&lt;CIBD&gt;());
            Something2(bar.Cast&lt;IA&gt;());

            // This call is illegal
            Something2(bar);

            return bar;
        }

        private static void Something2(IEnumerable&lt;IA&gt; foo)
        {
        }
    }

Error I get in `Something2(bar)` line:

&gt; Argument 1: cannot convert from &#39;System.Collections.Generic.List&lt;T&gt;&#39;
to &#39;System.Collections.Generic.IEnumerable&lt;ConsoleApp20.Program.IA&gt;&#39;

Problem understanding covariance contravariance with generics in C#

I didn&#39;t attend PDC 2008, but I heard some news that C# 4.0 is announced to support Generic covariance and contra-variance. That is, `List&lt;string&gt;` can be assigned to `List&lt;object&gt;`. How could that be?

In Jon Skeet&#39;s book ***C# in Depth***, it is explained why C# generics doesn&#39;t support covariance and contra-variance. It is mainly for writing secure code. Now, C# 4.0 changed to support them. Would it bring chaos?

Anybody know the details about C# 4.0 can give some explanation?


How is Generic Covariance &amp; Contra-variance Implemented in C# 4.0?

Please show a good example for covariance and contravariance in Java.

Give examples of functions which demonstrate covariance and contravariance in the cases of both overloading and overriding in Java?

**EDIT**: Re-written this question based on original answer

The `scala.collection.immutable.Set` class is not covariant in its type parameter. Why is this? 

    import scala.collection.immutable._

    def foo(s: Set[CharSequence]): Unit = {
        println(s)
    }

    def bar(): Unit = {
       val s: Set[String] = Set(&quot;Hello&quot;, &quot;World&quot;);
       foo(s); //DOES NOT COMPILE, regardless of whether type is declared 
               //explicitly in the val s declaration
    }



Why is Scala&#39;s immutable Set not covariant in its type?

I&#39;m working with the .NET framework and I really want to be able to make a custom type of page that all of my website uses. The problem comes when I am trying to access the page from a control. I want to be able to return my specific type of page instead of the default page. Is there any way to do this?

    public class MyPage : Page
    {
        // My own logic
    }
    
    public class MyControl : Control
    {
        public MyPage Page { get; set; }
    }

Does C# support return type covariance?

Is there way to override return types in C#? If so how, and if not why and what is a recommended way of doing it?

My case is that I have an interface with an abstract base class and descendants of that. I would like to do this (ok not really, but as an example!) :

    public interface Animal
    {
       Poo Excrement { get; }
    }

    public class AnimalBase
    {
       public virtual Poo Excrement { get { return new Poo(); } }
    }

    public class Dog
    {
      // No override, just return normal poo like normal animal
    }

    public class Cat
    {
      public override RadioactivePoo Excrement { get { return new RadioActivePoo(); } }
    }

`RadioactivePoo` of course inherits from `Poo`.

My reason for wanting this is so that those who use `Cat` objects could use the `Excrement` property without having to cast the `Poo` into `RadioactivePoo` while for example the `Cat` could still be part of an `Animal` list where users may not necessarily be aware or care about their radioactive poo. Hope that made sense...

As far as I can see the compiler doesn&#39;t allow this at least. So I guess it is impossible. But what would you recommend as a solution to this? 

C#: Overriding return types

I&#39;ve come across these in a textbook I am reading on C#, but I am having difficulty understanding them, probably due to lack of context.

Is there a good concise explanation of what they are and what they are useful for out there?

Edit for clarification:

Covariant interface:

    interface IBibble&lt;out T&gt;
    .
    .

Contravariant interface:
    
    
    interface IBibble&lt;in T&gt;
    .
    .

Understanding Covariant and Contravariant interfaces in C#

It seems that a List&lt;string&gt; object cannot be stored in a List&lt;object&gt; variable in C#, and can&#39;t even be explicitly cast that way.

    List&lt;string&gt; sl = new List&lt;string&gt;();
    List&lt;object&gt; ol;
    ol = sl;

results in Cannot implicitly convert type `System.Collections.Generic.List&lt;string&gt;` to `System.Collections.Generic.List&lt;object&gt;`

And then...

    List&lt;string&gt; sl = new List&lt;string&gt;();
    List&lt;object&gt; ol;
    ol = (List&lt;object&gt;)sl;

results in Cannot convert type `System.Collections.Generic.List&lt;string&gt;` to `System.Collections.Generic.List&lt;object&gt;`

Of course, you can do it by pulling everything out of the string list and putting it back in one at a time, but it is a rather convoluted solution.

In C#, why can&#39;t a List&lt;string&gt; object be stored in a List&lt;object&gt; variable

What is the different between the following Generics definitions in Scala:

    class Foo[T &lt;: List[_]]

and 

    class Bar[T &lt;: List[Any]]

My gut tells me they are about the same but that the latter is more explicit. I am finding cases where the former compiles but the latter doesn&#39;t, but can&#39;t put my finger on the exact difference.

Thanks!

**Edit:**

Can I throw another into the mix?

    class Baz[T &lt;: List[_ &lt;: Any]]



scala - Any vs underscore in generics

I have code like this:

    class RetInterface {...}

    class Ret1: public RetInterface {...}

    class AInterface
    {
      public:
         virtual boost::shared_ptr&lt;RetInterface&gt; get_r() const = 0;
         ...
    };

    class A1: public AInterface
    {
      public:
         boost::shared_ptr&lt;Ret1&gt; get_r() const {...}
         ...
    };

**This code does not compile.**

In visual studio it raises

&gt; C2555: overriding virtual function return type differs and is not
&gt; covariant

If I do not use `boost::shared_ptr` but return raw pointers, the code compiles (I understand this is due to [covariant return types][1] in C++). I can see the problem is because `boost::shared_ptr` of `Ret1` is not derived from `boost::shared_ptr` of `RetInterface`. But I want to return `boost::shared_ptr` of `Ret1` for use in other classes, else I must cast the returned value after the return.   

1. Am I doing something wrong? 
2. If not, why is the language like this - it should be extensible to handle conversion between smart pointers in this scenario? Is there a desirable workaround?

[1]: http://en.wikipedia.org/wiki/Parameter_covariance#C.2B.2B

How can I use covariant return types with smart pointers?

    class ResultBase {}
    class Result : ResultBase {}

    Task&lt;ResultBase&gt; GetResult() {
        return Task.FromResult(new Result());
    }

The compiler tells me that it cannot implicitly convert `Task&lt;Result&gt;` to `Task&lt;ResultBase&gt;`. Can someone explain why this is? I would have expected co-variance to enable me to write the code in this way.

Why is Task&lt;T&gt; not co-variant?

I start a few parallel tasks, like this:

	var tasks =
		Enumerable.Range(1, 500)
		.Select(i =&gt; Task.Factory.StartNew&lt;int&gt;(ProduceSomeMagicIntValue))
		.ToArray();

and then join them with

    Task.WaitAll(tasks);

On this last line I get a blue squiggly marker under `tasks`, with a warning message:

**&lt;pre&gt;Co-variant array conversion from Task&lt;int&gt;[] to Task[] 
can cause run-time exception on write operation.&lt;/pre&gt;**

I understand why I get this message, but is there a way around that? (for example, like a generic version of `Task.WaitAll()`?)

Is there a generic Task.WaitAll?

I am trying to figure out how to calculate covariance with the Python Numpy function cov.  When I pass it two one-dimentional arrays, I get back a 2x2 matrix of results.  I don&#39;t know what to do with that.  I&#39;m not great at statistics, but I believe covariance in such a situation should be a single number.  [This](http://i.investopedia.com/inv/articles/site/Proper%20Covariance.gif) is what I am looking for.  I wrote my own:

    def cov(a, b):
    
        if len(a) != len(b):
            return
    
        a_mean = np.mean(a)
        b_mean = np.mean(b)
    
        sum = 0
    
        for i in range(0, len(a)):
            sum += ((a[i] - a_mean) * (b[i] - b_mean))
    
        return sum/(len(a)-1)

That works, but I figure the Numpy version is much more efficient, if I could figure out how to use it.

Does anybody know how to make the Numpy cov function perform like the one I wrote?

Thanks,

Dave


Calculating Covariance with Python and Numpy

Look at the following example (partially taken from [MSDN Blog][1]):

    class Animal { }
    class Giraffe : Animal { }

    static void Main(string[] args)
    {
        // Array assignment works, but...
        Animal[] animals = new Giraffe[10]; 
    
        // implicit...
        List&lt;Animal&gt; animalsList = new List&lt;Giraffe&gt;();

        // ...and explicit casting fails
        List&lt;Animal&gt; animalsList2 = (List&lt;Animal&gt;) new List&lt;Giraffe&gt;();
    }

Is this a covariance problem? Will this be supported in the future C# release and are there any clever workarounds (using only .NET 2.0)?


  [1]: http://blogs.msdn.com/ericlippert/archive/2007/10/17/covariance-and-contravariance-in-c-part-two-array-covariance.aspx

C# variance problem: Assigning List&lt;Derived&gt; as List&lt;Base&gt;

The `IDictionary&lt;TKey, TValue&gt;` in .NET 4 / Silverlight 4 does not support covariance, i.e. I can&#39;t do a

    IDictionary&lt;string, object&gt; myDict = new Dictionary&lt;string, string&gt;();

analog to what I can do with `IEnumerable&lt;T&gt;`s now.

Probably boils down to the `KeyValuePair&lt;TKey, TValue&gt;` not being covariant either. I feel that covariance should be allowed in dictionaries at least for the values.

So is that a bug or a feature? Will it ever come, maybe in .NET 37.4?

UPDATE (2 years later):

There will be an [`IReadOnlyDictionary&lt;TKey, TValue&gt;`](http://msdn.microsoft.com/en-us/library/hh136548(v=VS.110).aspx) in .NET 4.5, but it won&#39;t be covariant either `:&#183;/`, because it derives from `IEnumerable&lt;KeyValuePair&lt;TKey, TValue&gt;&gt;`, and `KeyValuePair&lt;TKey, TValue&gt;` is not an interface and thus cannot be covariant.

The BCL team would have to redesign a lot to come up and use some `ICovariantPair&lt;TKey, TValue&gt;` instead. Also strongly-typed indexers &#225; la `this[TKey key]` aren&#39;t possible for covariant interfaces. A similar end can only be achieved by placing an extension method `GetValue&lt;&gt;(this IReadOnlyDictionary&lt;TKey, TValue&gt; self, TKey key)` somewhere which would somehow internally have to call an an actual implementation, which arguably looks like a quite messy approach.

IDictionary&lt;TKey, TValue&gt; in .NET 4 not covariant

What is the difference between covariance and upcasting, or, more specifically, why are they  given different names?

I&#39;ve seen the following example referred to as &#39;upcasting&#39;:

    string s = &quot;hello&quot;;
    object o = s;  //upcast to &#39;string&#39; to &#39;object&#39;

Whereas, the following I have seen called &#39;covariance&#39;:

    string[] s = new string[100];
    object[] o = s;

    IEnumerable&lt;string&gt; ies = new List&lt;string&gt;();
    IEnumerable&lt;object&gt; ieo = ies;

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?



Difference between covariance and upcasting

I know what covariance and contravariance of types are. My question is why haven&#39;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&#39;d like to articulate what that difference is.

Or maybe I&#39;m wrong and I just haven&#39;t learned enough Haskell yet :-)


Why aren&#39;t there many discussions about co- and contra-variance in Haskell (as opposed to Scala or C#)?

ok i read a bit on this topic on stackoverflow, watched [this][1] &amp; [this][2], but still a bit confused about co/contra-variance. 

from [here][3]

&gt; Covariance allows a &quot;bigger&quot; (less
&gt; specific) type to be substituted in an
&gt; API where the original type is only 
&gt; used in an &quot;output&quot; position (e.g. as
&gt; a return value). Contravariance allows
&gt; a &quot;smaller&quot; (more specific) type to be
&gt; substituted in an API where the
&gt; original type is only used in an
&gt; &quot;input&quot; position.

i know it has to do with type safety. 

about the `in/out` thing. can i say i use `in` when i need to write to it, and `out` when its read only. and `in` means contra-variance, `out` co-variance. but from the explanation above... 

and [here][4]

&gt; For example, a `List&lt;Banana&gt;` can&#39;t be
&gt; treated as a `List&lt;Fruit&gt;` because
&gt; `list.Add(new Apple())` is valid for
&gt; List&lt;Fruit&gt; but not for `List&lt;Banana&gt;`.

so shouldn&#39;t it be, if i were to use `in`/ am going to write to the object, it must be bigger more generic. 

i know this question has been asked but still very confused. 

  [1]: http://msdn.microsoft.com/en-us/vcsharp/ee672319.aspx
  [2]: http://channel9.msdn.com/posts/bruceky/Whirlwind-13-Whats-new-in-C-4-Covariance--Contravariance/
  [3]: https://stackoverflow.com/questions/1078423/c-is-variance-covariance-contravariance-another-word-for-polymorphism/1078469#1078469
  [4]: https://stackoverflow.com/questions/1078423/c-is-variance-covariance-contravariance-another-word-for-polymorphism

still confused about covariance and contravariance &amp; in/out

E.g. why does

    val list:List[Any] = List[Int](1,2,3)

work, but

    val arr:Array[Any] = Array[Int](1,2,3)

fails (because arrays are invariant). What is the desired effect behind this design decision?

Why are Arrays invariant, but Lists covariant?

I know that Java&#39;s type system is unsound (it fails to type check constructs that are semantically legal) and undecidable (it fails to type check some construct).

For instance, if you copy/paste the following snippet in a class and compile it, the compiler will crash with a `StackOverflowException` (how apt). This is undecidability.

    static class ListX&lt;T&gt; {}
    static class C&lt;P&gt; extends ListX&lt;ListX&lt;? super C&lt;C&lt;P&gt;&gt;&gt;&gt; {}
    ListX&lt;? super C&lt;Byte&gt;&gt; crash = new C&lt;Byte&gt;();

Java uses wildcards with type bounds, which are a form of use-site variance. C# on the other hand, uses declaration site variance annotation (with the `in` and `out` keywords). It is known that declaration-site variance is weaker than use-site variance (use-site variance can express everything declaration-site variance can, and more -- on the down side, it&#39;s much more verbose).

So my question is: Is C# type system sound and decidable? If not, why?

Is C# type system sound and decidable?

I would like a Covariant collection whose items can be retrieved by index.  IEnumerable is the only .net collection that I&#39;m aware of that is Covariant, but it does not have this index support.

Specifically, I&#39;d like to do this:

	List&lt;Dog&gt; dogs = new List&lt;Dog&gt;();

	IEnumerable&lt;Animal&gt; animals = dogs;
	IList&lt;Animal&gt; animalList = dogs; // This line does not compile

Now, I&#39;m aware of why this is a problem.  List implements `ICollection` that has an Add method.  By up casting to `IList` of Animals, it would allow subsequent code to add any type of animal which is not allowed in the &quot;real&quot; `List&lt;Dog&gt;` collection.

So is anyone aware of a collection that supports index lookups that is also covariant?  I would like to not create my own.





Covariance and IList

I am just trying to understand the `extends` keyword in Java Generics.

`List&lt;? extends Animal&gt;` means we can stuff any object in the `List` which **IS A** `Animal`

then won&#39;t the following also mean the same thing:

    List&lt;Animal&gt;

Can someone help me know the difference between the above two? To me `extends` just sound redundant here.

Thanks!

All Covariance Solutions on Gang of Coders

Total of 32 Covariance Solutions

<out T> vs <T> in Generics

Convert List<DerivedClass> to List<BaseClass>

Why are arrays covariant but generics are invariant?

Covariance and contravariance real world example

Difference between Covariance & Contra-variance

Why covariance and contravariance do not support value type

Co-variant array conversion from x to y may cause run-time exception

Why doesn't the example compile, aka how does (co-, contra-, and in-) variance work?

Covariance, Invariance and Contravariance explained in plain English?

What is a covariant return type?

Problem understanding covariance contravariance with generics in C#

How is Generic Covariance & Contra-variance Implemented in C# 4.0?

Give examples of functions which demonstrate covariance and contravariance in the cases of both overloading and overriding in Java?

Why is Scala's immutable Set not covariant in its type?

Does C# support return type covariance?

C#: Overriding return types

Understanding Covariant and Contravariant interfaces in C#

In C#, why can't a List<string> object be stored in a List<object> variable

scala - Any vs underscore in generics

How can I use covariant return types with smart pointers?

Why is Task<T> not co-variant?

Is there a generic Task.WaitAll?

Calculating Covariance with Python and Numpy

C# variance problem: Assigning List<Derived> as List<Base>

IDictionary<TKey, TValue> in .NET 4 not covariant

Difference between covariance and upcasting

Why aren't there many discussions about co- and contra-variance in Haskell (as opposed to Scala or C#)?

still confused about covariance and contravariance & in/out

Why are Arrays invariant, but Lists covariant?

Is C# type system sound and decidable?

Covariance and IList

Generics : List<? extends Animal> is same as List<Animal>?