Allow Existential types

[leandromoh]

Existential types, or 'existentials' for short, are a way of 'squashing' a group of types into one, single type.

Problem

For example, the LINQ Count method defines a T, but it really does not care about it; It does nothing with the T instance.

int Count<T>(IEnumerable<T> source);

This is bad, because it limit us unnecessarily. For example, if we have some object and case it is a generic enumerable, we want to count how many elements it has. This can not be simple done, because we need to supply T to call Count method, even when we does not care.

IEnumerable<string> GetNames() => ...;
IEnumerable<int> GetAges() => ...;

IEnumerable values = condition ? GetNames() : GetAges();

int? count = values is IEnumerable<string> texts ? texts.Count()
           : values is IEnumerable<int> integers ? integers.Count()
           : null;

I see 2 drawbacks here:

• have use super type (IEnumerable) to grup this values loosing the information that is a generic enumerable
• to check every possible "full type" to have a T and then be able to call Count

Solution

Discard T, where we does not care about it..

int Count<_>(IEnumerable<_> source);

Then

IEnumerable<string> GetNames() => ...;
IEnumerable<int> GetAges() => ...;

IEnumerable<_> values = condition ? GetNames() : GetAges();

int count = values.Count();

All runtime information is still there, and Count method as well values variable are still generic, the compiler just let us discard it since it is not relevant for the current context. Of course, we still could call Count with an IEnumerable<T> like string[], we are just not restrict to it.

An alternative approach, much simple, is allow something like following

IEnumerable values = ...;
int? count = values is IEnumerable<_> source ? source.Count() : null;

[333fred]

Duplicate of #1328.