Syntax to extend a type by an Interface

[hjrb]

Today we can extend a type by an method. But as far as I know one can not extend a type by an implementation of an interface. This limits the use to interfaces to only those that have been envisioned during the design of the type (just like virtual methods).

Example:
Interface to measure something.

/// <summary>an interface that projects to a numeric type</summary>
public interface IMeasure<T> where T: INumberBase<T>
{
	public T Measure();
}

Now this could be handy to implement routines without the need to provide lambda functions or projection (select), e.g. Sum

	public static L SumMeasured<T, L>(this IEnumerable<T> items) 
		where T: IMeasure<L>
		where L : INumberBase<L>
	{
		L sum = L.Zero;
		foreach (var item in items)
		{
			sum+=item.Measure();
		}
		return sum;
	}

Today we can not create a derived type of string, int or decimal as they are sealed to implement an interface that is not part of these types.
But with an extension syntax this would be possible.
The extension would not declare a method to extend a type but extend the type by the implementation of an interface. Here is a sample syntax:

///<summary>exten string to be measurable</summary>
public static this string  : IMeasure<int> {
   public int Measure()	=> this.Length;
   // more interface method implementations
}

Keyword usage:

• static - as it is not a member but extends a type in this example string
• this - indicates extension
• string - the type to be extended
• : the Interfaces to be implemented
  -{ /// } block: like the block of a class or interface
• inside block: code to implement the interface. Inside the this block the keyword this references the object instance of the extended type.

Having such a syntax would allow to move all the interface implementations from the classes to one central extension class for a specific interface.

With the interface extension this would work:
var strings=new string[] {"Hello", "World"}
var totalLength=strings.SumMeasured();
// today
totalLength=strings.Select(s=>s.Length).Sum();

I hope this is a good idea - let me know in the comments.

[HaloFour]

There are proposals underway to completely change how extensions work in C#, including support for more members and possibly (eventually) extension implementation.

See #8696

This is purely hypothetical given the current syntax design, but it could end up looking something like this:

public static class ListExtensions {
    // make a List<T> of disposables also be disposable
    extension<T> (List<T> list) : IDisposable
        where T : IDisposable {

        public void Dispose() {
            // dispose every item in the list
            foreach (T item in list) item.Dispose();
        }
    }
}

[huoyaoyuan]

Syntax is really the last piece of this feature. We must design and implement the mechanism in runtime/codegen first.

[HaloFour]

Of course, I only posted the syntax in terms of how I see "extension implementation" fitting into "extensions" in general. While that syntax is also not set in stone I think the extension grouping does lend nicely to supporting this functionality. How that is lowered is a completely different and much more involved question.

[333fred]

I'm going to close this discussion as a duplicate of extensions/roles.

[hjrb]

Thanks for pointing me to the right direction. It is quite hard to determine if an idea already exist for a non frequent user. Hope that #8696 will make progress.