Proposal: Flexible types in C#, probably the same as in F#.

[dmitriyse]

Suppose you have some method:

public void MyOperation(IReadOnlyDictionary<string, IReadOnlyList<int>> arg)
{
   // Do something.
}

Unfortunately IReadOnlyDictionary is not contravariant and Dictionary<string, List <int>> or Dictionar<string, int[]> is not supported directly by the method.
We can workaround this:

public void MyOperation<TList>(IReadOnlyDictionary<string, TList> arg) 
     where TList:IReadOnlyList<T>
{
     // Do something.
}

Looks ugly but works well.
Imagine that method will have 5+ parameters and most of parameters will have Dictionary - like contravariance problem. The same approach is possible but will completely kill code readability.

We can introduce "Ultra generic" syntax like this

public void MyComplexOperation(  
    IReadOnlyDictionary<string, like IReadOnlyList<int>> arg1,  
    IReadOnlyDictionary<object, like IReadOnlyDictionary<string, like IList<string>> arg2)  
{
   // Do something complex.
}

which is translates to classic c# 2.0 generic method:

public void MyComplexOperation<T1, T2, T3>(
IReadOnlyDictionary<string, T1> arg1, IReadOnlyDictionary<object, T2> arg2)
   where T1: IReadOnlyList<T1>
   where T2: IReadOnlyDictionary<string, T3>
   where T3: IList<string>
{
   // Do something complex.
}

So it is just syntax sugar, no any changes to CLR are required.

[Joe4evr]

Sounds like you want shapes from #164.

public shape SReadOnlyList<T>
{
    //your shape definition
}

public shape SReadOnlyDictionary<TKey, TValue>
{
    //your shape definition
}

public shape SList<T>
{
    //your shape definition
}

public void MyComplexOperation<T1, T2, T3>(
IReadOnlyDictionary<string, T1> arg1, IReadOnlyDictionary<string, T2> arg2)
   where T1: SReadOnlyList<T1>
   where T2: SReadOnlyDictionary<string, T3>
   where T3: SList<string>
{
   // Do something complex.
}

[dmitriyse]

Actually it's additional feature that it's well works with shapes suggested by you.

[alrz]

This feature exists in F# as "flexible types", with # syntax, something like this:

void M<T>(IReadOnlyDictionary<string, #IReadOnlyList<T>> arg) 
 // equivalent to
void M<T, TList>(IReadOnlyDictionary<string, TList> arg)  where TList : IReadOnlyList<T>

[dmitriyse]

Thank you for pointing. I renamed this issue.