improved auto generic type inference, proposal for backward compatibility.

[MkazemAkhgary]

this feature has been requested many times, #997

I'd like to propose a new syntax for improved generic type inference so that it will not be a breaking change. even though there are unusual scenarios where improvements in type inference can change behavior of existing programs.

use <::> notation so that compiler will use improved rules for type inference rather than using traditional rules.

var bar = bar.AsFoo<Bar<T>, T>(); 
var bar = bar.AsFoo<::>();               // equivalent
//...
public static Foo<TBar, T> AsFoo<TBar, T>(this TBar bar) where TBar : IBar<T>
{
     return new Foo<TBar, T>(bar);
}

---

Side proposal:

this notation is appealing to me, alternatives would be <> or <*>

or a more explicit version <,,,> where number of commas should be equal to number of type parameters minus 1.

maybe support it as partially specified type parameters. like <*, int, double, *>.

---

Notice: my main proposed syntax is <::> but I wanted to open discussion further. I'm not saying all of these must be supported, only one of them to achieve same result with backward compatibilities.

Its worth noting that traditional type inference works for most cases, but there are some cases that it just doesn't work, as already described, I think that <::> is short, concise and readable enough. also you are not forced to use <::> all the time.

note that <::> has always two colons, regardless of number of type parameters.

[iam3yal]

@MkazemAkhgary I'd prefer something like this bar.Foo<>() and to disambiguate further I'd go with something like bar.Foo<,,int>() or bar.Foo<_,_,int>() and from what I've read people pretty much sold on either one of these, although in the case of bar.Foo<_,_,int>() there's the issue that _ is a valid identifier so a slight breaking change but not sure how the LDM feels about it.

However, what do you really mean by the following?

use <::> notation so that compiler will use improved rules for type inference rather than using traditional rules.

Its worth noting that traditional type inference works for most cases, but there are some cases that it just doesn't work, as already described, I think that <::> is short, concise and readable enough. also you are not forced to use <::> all the time.

I'm not sure how having the colons there helps, can you think about a scenario where the other suggestions wouldn't suffice?

[MkazemAkhgary]

I suggested <::> because <> is usually used for unspecified generic type parameters for typeof keyword. although they are not conflicting at all, but I though maybe extra colons helps to better understand that this is using different type inference.

<> will be a valid choice too, I also like the partial way of <,,int> which can be helpful in few more scenarios.

[iam3yal]

@MkazemAkhgary Fair enough.

[ghord]

Another idea is to use var as in Dictionary<var, string>.

[iam3yal]

@ghord Yup, this would be cool. :)

[gafter]

@agocke is investigating extending type inference to take constraints into account.