Proposal: Allow partial generic specification

[rcmdh]

If the compiler is not able to infer all the generic type arguments on a call, you must specify all of them. I propose adding a way to let the compiler infer all is can, and only require the source code to specify the not inferrable type arguments.

This is particularly useful when the type arguments are complex and you only need to specify one type argument of many.

E.g. A cast extension method on a generic IEnumerable<>. This is a trivial example to demonstrate, I know the actual Cast extension works on the non-generic IEnumerable.

class Example
{
    static void Main()
    {
        IEnumerable<IEnumerable<string>> enumerable = Enumerable.Repeat(new [] {" "}, 10);
        var current = enumerable.Cast<IEnumerable<string>, string[]>();
        var possible = enumerable.Cast<TTarget: string[]>();
        var possible = enumerable.Cast<var, string[]>();
    }
}

static class Extensions
{
    public static IEnumerable<TTarget> Cast<TSource, TTarget>(this IEnumerable<TSource> col) 
        where TTarget : class
    {
        return col.Select(x => x as TTarget);
    }
}

[svick]

I think this is pretty much a duplicate of dotnet/roslyn#6207, which was closed as duplicate of #280.

[gafter]

This is not a dup because it offers var as one of the options for asking the compiler to infer the type argument.

[paulirwin]

@gafter The first possibility is a dupe: var possible = enumerable.Cast<TTarget: string[]>();

Removing that from discussion since that part is a dupe, that leaves the var case. I'll set aside the bikeshed discussion of what the keyword should be, simply noting the possible confusion as type arguments are not variables.

I view the var case above as an alternative implementation to dotnet/roslyn#6207 seeking the same goal. Taking an example from that issue:

void Foo<T1, T2, T3, T4, TResult>(T1 t1, T2 t2, T3 t3, T4 t4)
{
}

Foo<TResult: int>(0, 0, 0, 0);

With the var approach above, that would be:

void Foo<T1, T2, T3, T4, TResult>(T1 t1, T2 t2, T3 t3, T4 t4)
{
}

Foo<var, var, var, var, int>(0, 0, 0, 0);

Given the choice between the two, I'd pick the former.

[paulirwin]

Oops, I just saw #1349 - I'll make my comments over there if no one else has covered that.