Discard/Ignore Generic Parameter

[thomhurst]

I'm raising this as an idea to help in my scenario as the better type inference proposal is unlikely to be implemented due to breaking changes.

If I want to utilise generics but I don't care about, and will not use one or more types in a method, then the option to discard/ignore it would be great. This would mean when calling that method, we also don't need to provide those bits of type information.

Given the below code, even though we only care about the key, we have to declare the value as a generic constraint still and this means the user has to provide that information when calling the method, even though we don't care about it.

public static class Program
{
    public static void Main(string[] args)
    {
        var dictionary = new Dictionary<string, byte[]>
        {
            ["Blah"] = []
        };
        
        // This doesn't compile because we haven't passed it a type for the TValue
        dictionary.CustomContainsKey("1");
    }
}

public static class Extensions
{
    public static void CustomContainsKey<TDictionary, TKey, TValue>(this TDictionary dictionary, TKey key)
        where TDictionary : IDictionary<TKey, TValue>
    {
        // ...
    }
}

We could specify a generic type with a ? to state that we do not need that type information and will not be using it, and that it can match any type.

public static class Extensions
{
    public static void CustomContainsKey<TDictionary, TKey>(this TDictionary dictionary, TKey key)
        where TDictionary : IDictionary<TKey, ?>
    {
        // ...
    }
}

        // This compiles now because the method doesn't need any generic information for TValue
        dictionary.CustomContainsKey("1");

This shouldn't cause any breakages afaik because we wouldn't be able to declare another method with the same number of generic arguments because we'd get a conflict.

For methods / properties where we either would get returned that generic type, or would normally have to pass it in, could we just make those methods uncallable and not shown to intellisense?

[HaloFour]

Would be cool if .NET supported generic wildcards (especially bounded wildcards). It would require quite a bit of runtime work, though.

[zms9110750]

If the generic can still be constrained after omitting parameters, we can merge method overloads that have both generic and Type parameters into one.

Enum.GetNames<TaskStatus>();
Enum.GetNames(typeof(TaskStatus));

string[] GetNames<T = null>(Type? type = null) where T : struct, Enum
{
	type ??= typeof(T);

}

[FaustVX]

For your example, why not use 2 methods ?

string[] GetNames(Type type) 
{
  // ...
}

string[] GetNames<T>() where T : struct, Enum
=> GetName(typeof(T))

[zms9110750]

Because their logic is the same.A method that simply fills in some parameters and then calls another method seems to me like nothing has been done.
But users need to be cautious, as these are two different API and they may have differences.

[HaloFour]

Reinterpretting parameters from one form to another is a common and normal reason to overload.

One thing Java did with generics which is kind of nice is that Class<T> is generic, and String.class returns a Class<String>. Makes those typeof-like expressions work pretty well with generics.