(Yet) another attempt of extensions syntax

[mharthoorn]

Mads in hist latest talk (NDC London) showed of Extensions and the struggle over the years to find the right syntax. Since there were a lot of questions and some push back, I was wondering if that was also caused by that these syntax patterns deviate from existing C# patterns. In some cases that's necessary, but it can also make C# as a language less intuitive and harder to learn.

In the case of extensions, we should be able to use existing patterns more than is done in the latest proposal, without it becoming artificial. So here goes yet another attempt that also tries to reduce boiler plate like the current proposal. Hopefully opening up some new perspectives, at least.

Patterns taken from:

• Explicit Interface implementation
• Derived classes
• (existing) Extension methods

Note that i use this here to align with existing extension methods. Personally I think base might be an even better keyword.

extension ExampleExtensions
{
    // Instance method form:
    public int IEnumerable<T>.Select<T, T2>(Func<T, T2> func) 
    { 
        foreach(var item in this)
            yield return func(item);
    }

    // Property form:
    public int IEnumerable<T>.Count =
    { 
        get
        { 
            if (field is null) 
            {
                int field = 0;
                foreach(var item in this) field++;
            }

            return field;
        } 
    }
    
    // Indexer form:
    public int List<T>[int index] => this.ItemAt(index);

    // Operator form:
    public static operator Vector2 + (this Vector2 v1, Vector2 v2) { return new Vector2(v1.x = v2.x, v1.y+v2.y); }
    
    // Conversion form: 
    public static implicit operator string (this int i) => i.ToString();  
    public static implicit operator int (this string i) => int.Parse(i);  
    
    // Constructor form:
    public Vector2(float x, float y) 
    { 
        this.X = x; 
        this.Y = y; 
    }

    public static bool string.Concat(string s1, string s2) { return s1 + s2; }
}

This of course does not exclude the option of having the type declared at the root if all extensions are on the same type:
But also here new syntax is not required. Existing syntax should do fine.

extension ExampleExtension : List<int>
{
    public int Sum() 
    {
        int sum = 0;
        foreach(var nr in this) sum+= nr;
        return sum;
    }
    
    public static List<int> Empty => [];
    
    ...
}

[HaloFour]

See: #8916

[333fred]

There's also a number of examples in the existing working group documents that propose this syntax: https://github.com/dotnet/csharplang/blob/main/meetings/working-groups/extensions/extending-extensions-a-guide-to-relaxation.md#mixing-underlying-types-within-an-extension-declaration is one example.