.NET 10 Extensions

[JonF12]

Hello,

Thanks for the work on the library, it's been a joy to use on some of my projects.
I have a question about the new .NET 10 extensions feature

C# 14 will introduce this new syntax for extension methods

public static class Enumerable
{
    extension<TSource>(IEnumerable<TSource> source) 
    {
        public bool IsEmpty => !source.Any();
        public TSource this[int index] => source.Skip(index).First();
        public IEnumerable<TSource> Where(Func<TSource, bool> predicate) { ... }
    }
    // extension block, with a receiver type only
    extension<TSource>(IEnumerable<TSource>) // static extension members for IEnumerable<Source>
    {
        // static extension method:
        public static IEnumerable<TSource> Combine(IEnumerable<TSource> first, IEnumerable<TSource> second) { ... }
        // static extension property:
        public static IEnumerable<TSource> Identity => Enumerable.Empty<TSource>();
    }
}

One big change is being able to effectively create static extensions on the type itself

Is there any potential for this to be useful in LanguageExt for either allowing new patterns or improving elegance?

[louthy]

A couple of benefits:

• Standardisation of extensions: I am assuming that if the same extension gets implemented twice then the compiler can spot it, in a way that it doesn't right now. I have done this by accident a few times in this library, so if I can make the compiler catch my mistakes, that would be great.
• There may be scope for some useful static extension methods/properties
• There may be scope to extend existing .NET types to make them 'more functional'

But, on the whole, it's a very limited feature change. It's mostly syntactic sugar. Extension operators would have been nice (and useful), but they're not there. Another opportunity missed.

I also have come to the conclusion that the 'extension system' as a whole is a stupid mistake. It's like a half-arsed trait system with zero rigour. My goal (going forward) with language-ext is to reduce the amount of extension-methods to only those needed to make the traits idea work -- because, of course, the idiotic implementation of static interface methods means we can't call trait methods directly, we have to redirect them through an extension method (some of the decision making around the new C# features is honestly insane).