[Proposal] Generic Specialization/Extension: add generic partial<>, override<> and new<>

[Velocirobtor]

One thing I always miss, when I go to my c# projects from c++ is template specialization, so I propose a similar mechanism be added to c# reusing the keywords partial, override and new followed by angle brackets:

partial

partial is used to extend certain generic instantiations. It works like the normal partial, but only extends the classes that satisfy the constraint.

public class Base<T> {
    public static void Foo() { Console.WriteLine("Base<T>.Foo()"); }
    public void Bar() { Console.WriteLine("Base<T>.Bar()"); }
    public virtual void Baz() { Console.WriteLine("Base<T>.Baz()"); }

    //shorthand for complete partial class definition (see below); equivalent to partial class with single method BarPartial
    public partial<> void BarPartial() where T : IEnumerable { Console.WriteLine("Base<Enumerable>.BarPartial()"); }
}

//angle brackets after partial needed to differentiate it from normal partial
public partial<> class Base<T> where T : struct {
    // if T is struct, Base<T> is extended
    public static void FooPartial() { Console.WriteLine("Base<struct>.FooPartial()"); }

    public virtual void BazPartial() { Console.WriteLine("Base<struct>.BazPartial()"); }
}
//introduce extra generics for more complex cases
public partial<TVal> class Base<T> where T : IEnumerable<TVal> { /*...*/ }

Base<int>.FooPartial(); //ok -> Base<struct>.FooPartial()
Base<string>.FooPartial(); // compile time error: Foo<string> has no member FooPartial

var bStr = new Base<string>();
bStr.BarPartial(); // ok, string is IEnumerable -> Base<Enumerable>.BarPartial()
bStr.BazPartial(); // compile time error, string is not a struct!

var bInt = new Base<int>();
bInt.BarPartial(); //compile time error, int is not IEnumerable
bInt.BazPartial(); //ok, int is struct -> Base<struct>.BazPartial()

override

override allows to specialize generic methods/classes for certain constraints/concrete types.

public class Derived<T> : Base<T> {
    public static void FooGeneric<U>() { Console.WriteLine("Derived<T>.FooGeneric<U>()"); }
    //override/specialize Generic Methods on Method generics ...
    public static override<> void FooGeneric<U>() where U : struct { Console.WriteLine("Derived<T>.FooGeneric<struct>()"); }
    //... or class generics ...
    public static override<> void FooGeneric<U>() where T : struct { Console.WriteLine("Derived<struct>.FooGeneric<U>()"); }
    //or both
    public static override<> void FooGeneric<U>() where T : struct where U : struct { Console.WriteLine("Derived<struct>.FooGeneric<struct>()"); }

    //introduce new generics for complex cases
    //override base class impl only for 2-tuples
    public override<U, V> void Baz() where T : (U, V) { Console.WriteLine("Derived<tuple>.Baz()"); }
    // constraint on struct allowed  ^^^^^^^^^^^^^^^^ means, that T has to be of that type
    // also works for concrete types
    public override<> void Baz() where T : int { Console.WriteLine("Derived<int>.Baz()"); }

    public void Qux<T>(T param) { Console.WriteLine("Qux(T)"); }
    //shorthand for methods: first is equivalent to Qux<T>(T param) where T : int
    public override<> void Qux<int>(int param){ Console.WriteLine("Qux(int)"); }
    public override<U, V> void Qux<(U, V)>((U, V) param) { Console.WriteLine("Qux(tuple2)"); }
    //allow type deduction:
    public override<> void Qux(double param) { Console.WriteLine("Qux(double)"); }
    public override<U, V, W> void Qux((U, V, W) param) { Console.WriteLine("Qux(tuple3)"); }
}

void Dispatch1<T, U>() => Derived<T>.FooGeneric<U>();
Dispatch1<string, string>(); // -> Derived<T>.FooGeneric<U>()
Dispatch1<string, int>();    // -> Derived<T>.FooGeneric<struct>()
Dispatch1<int, string>();    // -> Derived<struct>.FooGeneric<U>()
Dispatch1<int, int>();       // -> Derived<struct>.FooGeneric<struct>()

void CallBase<T>(Base<T> b) => b.Baz();
CallBase(new Derived<string>()); // -> Base<T>.Baz()
CallBase(new Derived<(int, string)>()); // -> Derived<tuple>.Baz()

void Dispatch2<T>() => new Derived<int>().Qux(default(T));
Dispatch2<string>(); // -> Qux(T)
Dispatch2<int>();    // -> Qux(int)  (this cannot be achieved with overloading, which would have called Qux(T))

new

new hides more generic implementations. Specialized versions are only called, when the generic context allows it. (Probably the least usefull of the three, but here for completeness sake)

public class DerivedNew<T> : Base<T> {
    // hide more generic impementations with more specialized ones
    public static void FooGeneric<U>() { Console.WriteLine("DerivedNew<T>.FooGeneric<U>()"); }
    // will only be called if the generic context is at least as constrained as the context in which the method is called
    public static new<> void FooGeneric<U>() where U : struct { Console.WriteLine("DerivedNew<T>.FooGeneric<struct>()"); }

    //hide Bar of Base when T is a struct
    public void new<> Bar() where T : struct { }
}

void Dispatch1<T, U>() => DerivedNew<T>.FooGeneric<U>(); //no constraint, will always call the most generic version
Dispatch1<string, string>(); // -> DerivedNew<T>.FooGeneric<U>()
Dispatch1<string, int>();    // -> DerivedNew<T>.FooGeneric<U>()

void Dispatch2<T, U>() where U : struct => DerivedNew<T>.FooGeneric<U>(); //constraint! will call the more specialized version
Dispatch2<string, int>(); // -> DerivedNew<struct>.FooGeneric<U>()

(Hopefully) useful example

public struct Tuple2<T1, T2>{ 
    public T1 Item1;
    public T2 Item2;
}

public partial<T> struct Tuple2<T, T> : IEnumerable<T> { //shorthand for Tuple2<T1, T2> where T1 : T where T2 : T
    /* implement IEnumerable */
    public T this[int index] { get { /*...*/ } set { /*...*/ } }
}

public partial<> struct Tuple2<T1, T2> : IEquatable<Tuple2<T1, T2>>
        where T1 : IEquatable<T1> where T2 : IEquatable<T2> {
    /* implement IEquatable */
    /* also implement operator == and != */
}

var tIntDouble = new Tuple2<int, double> { Item1 = 1, Item2 = 3.141 };
Debug.Assert(tIntDouble == tIntDouble); //works, since both int and double are IEquatable
tIntDouble[0] = 5; //compile time error

var tIntInt = new Tuple2<int, int> { Item1 = 21, Item2 = 84 };
tIntInt[0] *= 2;
tIntInt[1] /= 2;
foreach (var elem in tIntInt) { Console.WriteLine(elem); } // works, elem is int
Debug.Assert(tIntInt == new Tuple2<int, int>{ Item1 = 42, Item2 = 42 })

The Same could be applied to System.ValueTuple for useful extra features, when applicable.
If Concepts/shapes (#110, #164) are added to the language, much more complex scenarios are possible.

AFAIK the runtime emits specialized code for structs when it resolves generics, so it should be possible as long as the specialization is always constrained to struct. However, I would love for it to work on any type.

I chose the keywords partial, override and new because they already exist and behave to some point similarly to the proposed versions, however other keywords like extend and specialize would of course also work.

[HaloFour]

So your proposal is that the shape of the generic type would change based on the generic type arguments? That is quite counter to the nature and design of CLR generics. The members are always static and known even when the generic type is completely open.

How would you propose that any of this be implemented at the CLR level?

[Velocirobtor]

AFAIK generic types are different based on arguments (as long as the arguments are structs), so List<int>!= List<double> (unlike java, where generics are little more than casts). I thought, that because the types are already different, it could be possible to add code to only particular instantiations. However, I am not really well acquainted with the CLR, so maybe I am just plain wrong here...

But Method specializations could all be lifted into a single Method with a huge if typeof(T) == ... And the JIT would optimize that method for different types.

[Velocirobtor]

Also, maybe something similar to the trick in the concepts/shape proposal might work:

public class Test<T> {
    public void Foo() { }
    public partial<> void Baz() where T : int => Console.WriteLine("IntBaz");
}

partial<> class Test<T> where T : struct {
    public void Bar() => Console.WriteLine("StructBar");
    public override<> void Bar() where T : int => Console.WriteLine("IntBar");
}

could be translated to:

public static class Test<T> {
    public interface ITest { }
    public struct TestDefault : ITest { }

    public interface ITestStruct<TImpl> : ITest where TImpl : ITestStruct<TImpl> {
        void Bar(Test<T, TImpl> @this);
    }

    public struct TestExtraStruct : ITestStruct<TestExtraStruct> {
        public void Bar(Test<T, TestExtraStruct> @this) => Console.WriteLine("StructBar");
    }

    public interface ITestInt<TImpl> : ITestStruct<TImpl> where TImpl : ITestInt<TImpl> {
        void Baz(Test<T, TImpl> @this);
    }

    public struct TestExtraInt : ITestInt<TestExtraInt> {
        public void Bar(Test<T, TestExtraInt> @this) => Console.WriteLine("IntBar");
        public void Baz(Test<T, TestExtraInt> @this) => Console.WriteLine("IntBaz");
    }
}
public class Test<T, TImpl> where TImpl : struct, Test<T>.ITest {
    void Foo() { }
    public TImpl impl = default(TImpl);
}

Then this:

var tString = new Test<string>();

var tDouble = new Test<double>();
tDouble.Bar();

var tInt = new Test<int>();
tInt.Bar();
tInt.Baz();

void test<T>(Test<T> t) where T : struct 
    => t.Bar();
test(tDouble); // -> StructBar
test(tInt);        // -> IntBar

would be translated to this:

var tString = new Test<string, Test<string>.TestDefault>();

var tDouble = new Test<double, Test<double>.TestExtraStruct>();
tDouble.impl.Bar(tDouble);

var tInt = new Test<int, Test<int>.TestExtraInt>();
tInt.impl.Bar(tInt);
tInt.impl.Baz(tInt);

void test<T, Timpl>(Test<T, Timpl> t) where T : struct where Timpl : struct, Test<T>.ITestStruct<Timpl>
    => t.impl.Bar(t);

test(tDouble); // -> StructBar
test(tInt);    // -> IntBar

[iam3yal]

Related #905.