[Proposal] Type alias in class/interface declaration

[Orace]

This is a proposal to add type aliases in class and interface declaration.

Example

Considering this scenario:

// Interface for cachable
interface ICachable<T>
{
   T WithCache();
}

interface IDataProvider<TSource, TData> :
    ICachable<IDataProvider<TSource, TData>> // fluent pattern
{
}

...

ExampleOfUse(IDataProvider<TSource, TData> dataProvider)
{
  var cachedDataProvider = dataProvider.WithCache();
}

The goal of this proposal is to simplify the declaration of IDataProvider like this:

interface IDataProvider<TSource, TData> as TSelf:
    Cachable<TSelf> // fluent pattern
{
}

-A type alias lifetime is limited to the class / interface in which it's declared
-A type alias is visible from inner class
-A type alias is not visible to herited / implementing class
-A type alias have the same constraints as a type parameter
-A type alias can't be used before its declaration

Example of valid use

class IntToStuffMapper as TSelf : IReadonlyDictionary<int, Stuff> as TSingleton
{
  // public static IReadonlyDictionary<int, Stuff> Instance { get; } = new IntToStuffMapper();
  public static TSingleton Instance { get; } = new IntToStuffMapper();
}

class TypeWithManyFluentOverload<T1, T2> as TSelf:
  ICachable<TSelf>,
  IFoozable<TSelf>
{
}

Example of invalid use

-A type alias is not visible to herited / implementing class

class IntToStuffMapper as TSelf : IReadonlyDictionary<int, Stuff> as TSingleton {...}

class SpecializedIntToStuffMapper : IntToStuffMapper
{
  public static TSingleton Instance { get; } = new SpecializedIntToStuffMapper(); // error TSingleton not declared
}

-A type alias can't be used before its declaration

interface IFoo<T> {...}
interface IBar<T> {...}

// If you think that self-aware type may reboot the universe look at this buzz.
// It implement: IFoo<IBar<IFoo<IBar<...>>>>
//          And: IBar<IFoo<IBar<IFoo<...>>>>
class Buzz :
  IFoo<TBar> as TFoo, // error TBar used before its declaration
  IBar<TFoo> as TBar
{
}

[Orace]

An optional part of this proposal is that a type alias for the current class may be used for call to any constructor.

class Test<T1, T2> as TSelf
{
  public static TSelf Build() => new TSelf();
  public static TSelf Build(int v) => new TSelf(v);
  public static TSelf Build(string s) => new TSelf(s);
  
  Test() {}
  Test(int v) {}
  Test(string s) {}
}