Alternative extensions syntax related to LDM October 14th, 2024

[OJacot-Descombes]

What about overloaded extensions, i.e., extensions having the same name, but for different types?

Instead of the syntax proposed in the LDM for October 14th, 2024

extension E
{
    for IEnumerable<T> where T
    {
        public void M1() { ... }
    }

    for IList<T> where T
    {
        public void M2() { ... }
    }
}

we would have

extension E for IEnumerable<T> where T
{
    public void M1() { ... }
}

extension E for IList<T> where T
{
    public void M2() { ... }
}

And we could introduce the type parameter like this:

extension E<T> for IEnumerable<T> where T
{
    public void M1() { ... }
}

extension E<T> for IList<T> where T
{
    public void M2() { ... }
}

[HaloFour]

Similar spaghetti at the wall, partial extensions that each can have a different target. If combined with flattening the generics (e.g. the extension generic type parameters are prepended to the extension members), that would also make them binary compatible with existing extension methods.

public partial extension Enumerable for IEnumerable {
    public IEnumerable<T> OfType<T>() { ... }
}

public partial extension Enumerable<T> for IEnumerable<T> {
    public IEnumerable<T> Where(Func<T, bool> predicate) { ... }
}

public partial extension Enumerable<T> for IOrderedEnumerable<T> {
    public IOrderedEnumerable<T> ThenBy<TKey>(Func<T, TKey> selector) { ... }
}

public partial static class Enumerable {
    public static IEnumerable<T> Empty<T>() { ... }
}

[333fred]

This version of the syntax did come up during the meeting. It still has the problem of "where is the type parameter introduced", so we're not satisfied with it.

[CyrusNajmabadi]

@CyrusNajmabadi I had originally suggested as a strawman that where T could declare T

Right. That might be a solution to the "where is the type parameter declared" issue. But I def think it's not an obvious thing.

[jnm2]

Just dreaming, but associated type declaration syntax could move the location of the T declaration in a way that comes together nicely with this.

[CyrusNajmabadi]

Just dreaming, but associated type declaration syntax could move the location of the T declaration in a way that comes together nicely with this.

What do you think that would look like here? :-)

[jnm2]

Something I'd have to sit on. But where could morph into the declaration line for the associated type, maybe on the other side of the curly brace. e.g. class T : IEnumerable<T>; is valid today and introduces a nested type, and where T : IEnumerable<T>; could then introduce an associated type. (Same with class T; and where T;)

[Richiban]

We could take inspiration from (I think) Kotlin, and have something like extension<T> E for IEnumerable<T> { ... }