Why isn’t there generic variance for classes in C# 4.0?

by

Suppose you had a class C<T> that was covariant in T. What might its implementation look like? T has to be out only. That means that C<T> cannot have any method that takes a T, any property of type T with a setter, or any field of type T, because fields are logically the same as property setters; T goes in.

Pretty much the only useful thing you could build with a covariant class is something immutable as far as T is concerned. Now, I think it would be awesome to have covariant immutable lists and stacks and whatnot that were class types. But that feature is not so obviously awesome that it would clearly justify the massive expenditure in making the type system natively support covariant immutable class types.

A comment above asked for an example of where this would be useful. Consider the following sketch:

sealed class Stack<out T>
{
    private readonly T head;
    private readonly Stack<T> tail;
    public T Peek() { return head; }
    public Stack<T> Pop() { return tail; }
    public Stack(T head, Stack<T> tail)
    {
        this.tail = tail;
        this.head = head;
    }
}
static class StackExtensions
{
    public static Stack<T> Push<T>(this Stack<T> tail, T head) 
    {
        return new Stack<T>(head, tail);
    }
    public static bool IsEmpty<T>(this Stack<T> stack)
    {
        return stack == null;
    }
}

Suppose you had covariant classes. Now you can say

Stack<string> strings = null;
strings = strings.Push("hello");
strings = strings.Push("goodbye");
Stack<object> objects = strings;
objects = objects.Push(123);

And hey, we just pushed an integer onto a stack of strings, but everything worked out just fine! There’s no reason why this couldn’t be typesafe. An operation which would violate type safety on a mutable data structure can be safely covariant on an immutable data structure.

More Related Contents:

  1. C# Create New T()
  2. Why covariance and contravariance do not support value type
  3. In C#, why can’t a List object be stored in a List variable
  4. Why doesn’t C# infer my generic types?
  5. What are the true benefits of ExpandoObject?
  6. Parse Math Expression [duplicate]
  7. Making a generic property
  8. foreach vs someList.ForEach(){}
  9. Why cannot C# generics derive from one of the generic type parameters like they can in C++ templates? [duplicate]
  10. No type inference with generic extension method
  11. Passing a single item as IEnumerable
  12. How do I make the return type of a method generic?
  13. Static Generic Class as Dictionary
  14. Get a generic method without using GetMethods
  15. explicitly cast generic type parameters to any interface
  16. Anonymous Types – Are there any distingushing characteristics?
  17. A reusable pattern to convert event into task
  18. C# Generic Type Inference With Multiple Types
  19. Parse string to enum type
  20. Declare a generic type instance dynamically [duplicate]
  21. T must be contravariantly valid
  22. Ambiguous call between two C# extension generic methods one where T:class and other where T:struct
  23. How do I tell if a type is a “simple” type? i.e. holds a single value
  24. Why doesn’t C# support implied generic types on class constructors?
  25. What’s Wrong with an ArrayList?
  26. Implementing arithmetic in generics?
  27. DataGridView column footer c#.net winforms
  28. How does a generic constraint prevent boxing of a value type with an implicitly implemented interface?
  29. How to make correct clone of the List? [duplicate]
  30. C# generic methods, type parameters in new() constructor constraint

Leave a Comment