[Proposal] Allow covariance (out) for generic out parameters

[mrange]

Hi. I tried searching for this but didn't find it. Feel free to close if it's been discussed and dismissed earlier.

I am suggesting to allow covariance out for generic out parameters.

delegate void OutDelegate<out T>(out T v);

interface OutInterface<out T>
{
  void DoStuff(out T v);
}

Today the C# compiler responds:

error CS1961: Invalid variance: The type parameter 'T' must be invariantly valid on 'OutInterface<T>.DoStuff(out T)'. 'T' is covariant.
error CS1961: Invalid variance: The type parameter 'T' must be invariantly valid on 'OutDelegate<T>.Invoke(out T)'. 'T' is covariant.

From my uninformed point of view an out parameter is similar to return values and this does compile and work as expected in C#.

delegate T OutDelegate<out T>();

interface OutInterface<out T>
{
  T DoStuff();
}

There might be subtle or obvious details that I am not seeing that makes covariance on out parameters not possible.

Motivation:

The reason I ran into this was that I been experimenting with parser combinators in C# and ended up with this definition:

delegate bool Parser<T>(string input, ref int pos, out T value);

I wanted this to be covariant but as the examples above demonstrate currently this is not supported.

[HaloFour]

IIRC this is because out is largely a C# construct and that the parameter is really ref with a metadata hint and managed references can't be variant in the runtime.

[333fred]

This is correct. That's not to say we could never make this work, but it's definitely a lot more complex than return variance.

[fitdev]

Hopefully this will be addressed nonetheless, as I just hit this limitation.

[jilles-sg]

Allowing this with the current behaviour of out parameters would be unsound, since out parameters can be both read after being written once and aliased (for example because the method taking the out parameter also takes a ref parameter pointing to the same variable, or because the out parameter refers to a static field or a field of a reference type).

The following wrong example uses Unsafe to force the requested conversion and accesses a Base instance using a variable of type Derived. The behaviour is undefined, but in my testing it writes readBack = Base.

using System.Runtime.CompilerServices;

VarianceExample<Derived> f = (ref Base x, out Derived y) => {
    y = new Derived();
    x = new Base();
    Derived readBack = y;
    Console.WriteLine($"readBack = {readBack}");
};
VarianceExample<Base> v = Unsafe.As<VarianceExample<Base>>(f);
Base b = new();
v(ref b, out b);

delegate void VarianceExample<T>(ref Base x, out T y);

class Base { }
class Derived : Base { }

Do not use Unsafe.As like this in production code. There is the risk of not only crashes but criminals breaking in.

[weitzhandler]

Addressing this can potentially unlock covariance in many important interfaces, e.g. IReadOnlyDictionary<TKey, out TValue> (#2175).

[333fred]

I mean, it would be interesting, sure, but until someone has a proposal for how to make ref allow variance safely, this cannot happen.

[jaredpar]

There is no way to make ref variance safe. The change would be more to make the runtime treat out as out at a very deep type system level.