Alias Extensions (Proposal)

[TimberStalker]

Alias Extensions

Summary

The idea behind alias extensions is to provide the ability to add methods/properties/interfaces to preexisting types without modifying them directly. This would be useful in adding interfaces to types they are not accessible to the developer.

Other similar proposals exist, however this prioritizes reusing existing keywords and keeping syntax similar to constructs already in c#.

Motivation

It is difficult to add interfaces and methods to predefined datatypes that the developer doesn't have access to.

Detailed design

The way to define an alias extension is as follows:

using Currency = int { } 

At this point, the Currency alias functions very similar to a normal type alias. However, some differences apply.

1. Alias Extensions are accessible within the namespace they are defined in. However, if defined outside of a namespace, they are only accessible to the file as normal.
2. The type being aliased must be cast to the alias type, and cannot be directly assigned. For example Currency price = 1; would produce a syntax error while Currency price = (Currency)1; would not.

The reason why the int must be cast directly to the Currency type alias is because alias extensions are implicitly preceded with an explicit modifier. In order for a type to be implicitly assigned to its alias(and vise versa) is to prefix the using declaration with the implicit modifier. (Note: Two aliases aliasing the same type must always be cast to the other alias upon assignment, irrespective of the explicit/implicit modifiers defined on them.)

Adding extensions methods, properties, or interfaces (aliases may also be assigned their own attributes) can be done as follows:

[FizzAttribute]
explicit using Currency = int : IFoo 
{
    public int Cents => this % 100;
    public int Dollars => this / 100;

    public void Foo()
    {
        throw new NotImplementedException();
    }
} 

• Now, the Currency type alias implements IFoo, and has the Cents and Dollars properties accessible. In order to use it, any int simply needs to be cast to the Currency alias, and all defined items can be used.
• An alias extension cannot define fields, and as such cannot use auto generated properties.
• Aliases can contain static fields, methods, and properties.

An alias extension may define a constructor, however, the constructor must be parameterless, and only executes upon a type being casted to the alias. As such, all values of the original type have already been set. For more complex actions upon casting, it is expected for one to create a static method on the alias that accepts the original type and returns the alias.

Drawbacks

Complexity is added to the code, and random functions that were not originally on types may start appearing.
Additionally, as methods, interfaces ect are not added to the original type, code may be littered with aliases.

Alternatives

What other designs have been considered? What is the impact of not doing this?

Unresolved questions

• Aliases are not types. They are simply an alias that defines extra properties. This interferes with reflection, as a common use case is to select over types.
• The original type never knows about the alias or what the alias adds. This may be open to change as properties and methods could be accessible to the original type when using an implicit alias extension.

Design meetings

Link to design notes that affect this proposal, and describe in one sentence for each what changes they led to.

[FaustVX]

You should look into implicit/explicit extensions (formerly Roles & Extensions) #5497

[TimberStalker]

Yes. I mentioned that other similar ideas exist and are likely far more thought out. I just said that this was a syntax I found preferrable, since it uses existing keywords and constructs.