Nullable-generics interaction doesn't work as expected.

[mlavrent]

I posted this question recently about how generic return types and the handling of nullable types is handled and how it seems to be not correct.

The TL;DR is this: if I have a method static A? Test<A>(A input) => default(A?) that has a nullable return type, it seems to behave incorrectly for value types such as bool e.g. Test(true) has type bool instead of type bool? (or, more explicitly Nullable<bool>). This seems to be a result of the fact that the desugaring of nullable types is different depending on whether the type is a reference type or value type.

The bug (is it a bug or expected?) lies the case where it's a nullable generic parameter that is unconstrained to be either a reference type (i.e. where A : class) or a value type (i.e. where A : struct). In this case, it gets desugared into the version for reference types, causing the weird behavior when A is a a value type such as bool.

Are there plans to address this? This behavior seems to be incorrect since the actual type of the expression Test(true) is bool even though the method's return type is nominally bool?.

[CyrusNajmabadi]

This is by design. When T is unconstrained (no struct or class constraint) then T? simply means "can have its default value" (not can be null).

If you have the class constraint then it is known to be a reference type, and can be null. Similarly, if you have the struct constraint then T? means Nullable<T> which can also be null.

Are there plans to address this?

No. This has been how generics have worked in .net and c# for 20 years. Far too much code has been written that depends on things working in this exact fashion.

[mlavrent]

Interesting, this is nice context to know!

[mlavrent]

On a related, but orthogonal note, are there plans to add Haskell-style Option/Maybe types to the stdlib?

[HaloFour]

See: #113

There's been a bit of movement in this space recently, mostly explorations:

#7016
#7544

It's unlikely that the BCL team would adopt any form of common discriminated union like Maybe<T> or Result<T> without a good story in the language.