Proposal: Generic type constraint for all nullable types

[lachbaer]

There are sometimes scenarios where a generic class or function is always valid for nullable value types as well as (nullable) reference types.

Currently there is no other way as to duplicate the code

static IEnumerable<T> GetNonNullitemList<T>(IEnumerable<T> list) where T : class
{
   return list.Where(x => x != null);
}
static IEnumerable<T?> GetNonNullitemList<T>(IEnumerable<T?> list) where T : struct
{
    return list.Where(x => x != null);
}

I propose a type constraint ? (or ??, or ???) that allows for all nullable types

static IEnumerable<T> GetNonNullitemList<T>(IEnumerable<T> list) where T : ?
{
    return list.Where(x => x != null);
}

The "Questionmark" ? would fit in nicely with the current meanings.

This could be extended to allow only non-nullable types and non-nullable reference types

static IEnumerable<Type> GetTypeList<T>(IEnumerable<T> list) where T : !
{
    // we can safely call a method on x, because x cannot be null
    return list.Select(x => x.GetType());
}

[yaakov-h]

This seems like it should be considered as a part of #36, not it's own feature.

[svick]

static IEnumerable<T> GetNonNullItemList<T>(IEnumerable<T> list) where T : ?
{
    return list.Where(x => x != null);
}

So, if I pass IEnumerable<int?> in, I get IEnumerable<int?> back, even though it won't contain any nulls? I don't think that's good enough.

In my opinion, what you want is to be able to write T? without having to constrain it to struct. E.g.:

static IEnumerable<T> GetNonNullItemList<T>(IEnumerable<T?> list)
{
    return list.Where(x => x != null).Select(x => (T)x);
}

The problem with this is that there is no good way to express it at the IL level. But maybe it could work with some kind of CLR modification.

[lachbaer]

@svick

So, if I pass IEnumerable<int?> in, I get IEnumerable<int?> back, even though it won't contain any nulls? I don't think that's good enough.

In this special case, yes. But if you enter reference types, then it fits.
As probably non-nullable reference types will come, with an ! token that shall somehow ensure non-nullness, the following modification could work.

static IEnumerable<T!> GetNonNullitemList<T>(IEnumerable<T> list) where T : ?
{
    return list.Where(x => x != null).Select(x => (T!)x);
}

Update:
In case there is a different outcome of functions there must be overloads anyhow.

// the generic class accepts all nullable types
class Tools<T> where T : ?
{
    // no casting on returned value for reference types
    public IEnumerable<T> GetNonNullitemList<T>(IEnumerable<T> list) where T : class
        => list.Where(x => x != null);

    // casting on retured value for value types
    public IEnumerable<T> GetNonNullitemList<T>(IEnumerable<T?> list) where T : struct
        => list.Where(x => x != null).Select(x => (T)x);
}

[CyrusNajmabadi]

Why not just have:

static IEnumerable<T> GetNonNullitemList<T>(IEnumerable<T?> list) where T : struct
    => list.Where(x => x != null).Select(x => x.value);

static IEnumerable<T> GetNonNullitemList<T>(IEnumerable<T> list) where T : class
    => list.Where(x => x != null);

This will work on lists of nullables, and lists of reference types. It will appropriately not work on lists of value types.

[jnm2]

@CyrusNajmabadi If overload resolution let us have that, it would be amazing.

[CyrusNajmabadi]

Overload resolution should give you that today. I just tested and it worked exactly as expected:

    static IEnumerable<T> GetNonNullitemList<T>(IEnumerable<T?> list) where T : struct
        => list.Where(x => x != null).Select(x => x.Value);

    static IEnumerable<T> GetNonNullitemList<T>(IEnumerable<T> list) where T : class
        => list.Where(x => x != null);

    void Test(IEnumerable<int> structs, IEnumerable<int?> nullables, IEnumerable<string> classes)
    {
        // GetNonNullitemList(structs); <-- get compiler errror.
        GetNonNullitemList(nullables);
        GetNonNullitemList(classes);
    }

[orthoxerox]

@CyrusNajmabadi it will break when it's the return type that is nullable:

static T? SafeGet(IReadOnlyList<T> source, int index)
    => (index >= 0 && index < source.Count) ? source[index] : null;

[lachbaer]

@CyrusNajmabadi
And it is code duplication, because if T? would also respect all nullable types, i.e. including reference types, the same could be expressed as

    static IEnumerable<T> GetNonNullitemList<T>(IEnumerable<T?> list)
        => list.Where(x => x != null).Select(x => (T)x);

A possible where T : ? could tell the compiler to generate the two variants, but with the same contents

    IEnumerable<T> GetNonNullitemList<T>(IEnumerable<T?> list) where T : struct
    IEnumerable<T> GetNonNullitemList<T>(IEnumerable<T> list) where T : class

Same goes for where T : ! and T!. That must say, that the supplied type must be non-nullable

// we can safely call a method on x, because x cannot be null
static IEnumerable<Type> GetTypeList<T>(IEnumerable<T!> list) where T : !
    => list.Select(x => x.GetType());

The : ! would tell the compiler to create two versions, one for struct, one for class.

In case of a CLR change, the where T : ? / ! can be ommited if just T? and T! respect all (non)-nullable types and do not rely on the System.Nullable<T> type.

[Pyrdacor]

I know this is old but is there a plan to implement this? I ran into this problem several times lately.

Another example:

    static class DictionaryExtensions
    {
        public static TValue SafeGet<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key) where TValue : class
        {
            return dictionary.TryGetValue(key, out TValue value) ? value : null;
        }

        public static TInnerValue SafeGet<TKey, TInnerKey, TInnerValue>(this Dictionary<TKey, Dictionary<TInnerKey, TInnerValue>> dictionary, TKey key, TInnerKey innerKey) where TInnerValue : class
        {
            return dictionary.SafeGet(key)?.SafeGet(innerKey);
        }
    }

This works fine for reference types. But when I want to use it for nullable value types it breaks as the first SafeGet uses a dictionary where TValue is a dictionary itself and this is of course a reference type.