Type Parameter for Current Type in Generics

[phi1010]

Implementing meta-functionality, such as custom IClonable-s, ICloneManager-s, IConvertableTo-s, ISynchronizable-s, etc. currently seems hard, without using runtime type checks. Some problems can be worked around by using excess type parameters and constraints, to other problems I don't see a solution only relying on type safety by compiler restraints.

I would like to define type constraints and parameters in interfaces with a new keyword such as thistype, which would represent an implicit type parameter that can optionally be explicitly defined, to add covariance/contravariance. It would be implicitly added to all derived classes/interfaces and represent the type actually instanciated; adding possibility to self-reference generic types (new MyClass<MyClass<MyClass<...>>>() would take a while to write...).

I think there was already a similar suggestion in the comments of a C#6 generics issue 1--2 years ago, but I wasn't able to find it anymore, it might have been closed with the ticket containing it.

ICloneable Example

interface ICloneable<out thistype> // allow to explicitly specify thistype for covariance/contravariance
{
    thistype Clone();
}

class Cloneable : ICloneable { /* ... */ }// typeparam automatically filled in. 

new MyClass().Clone() would have to return a MyClass, as well as ((BaseClass) new MyClass()).Clone() would do. Such methods would currently either require being reimplemented in every class or being defined inheritable, if there are mechanisms allowing base class code to handle specialized objects:

class BaseClass : IClonable, IMechanism
    where thistype : new()
{
    // already possible for other type parameters using 
    // IInterface<TTypeparam>.Method(TTypeparam parameter)
    public virtual thistype IClonable.Clone<thistype>()
        { return (new thisclass()).Populate(this) }
}
interface IMechanism
{
    thistype Populate(thistype objectToClone);
}

IParent-IChild Example

This already works in most cases, but requires a lot of code:

    interface IParent<TParent, TChild>
        where TParent : IParent<TParent, TChild>
        where TChild : IChild<TParent, TChild>
    {
        TChild DoSomething(TChild child);
    }

    interface IChild<TParent, TChild>
        where TParent : IParent<TParent, TChild>
        where TChild : IChild<TParent, TChild>
    {
        TParent DoSomething(TParent parent);
    }

    abstract class Parent : IParent<Parent, Child>
    {
        public Child DoSomething(Child child)
        {
            child.DoSomething(this);
            return child;
        }
    }

    abstract class Child : IChild<Parent, Child>
    {
        public Parent DoSomething(Parent parent)
        {
            parent.DoSomething(this);
            return parent;
        }
    }

Using thisclass might make such type constraints much simpler:

    interface IParent<TChild>
        where TChild : IChild<thistype>
        // Any IParent implementation works with childs,
        // that work with that IParent implementation
    {
        TChild DoSomething(TChild child);
    }

    interface IChild<TParent>
        where TParent : IParent<thistype>
    {
        TParent DoSomething(TParent parent);
    }

    abstract class Parent : IParent<Child> // would be valid, because Child : IChild<Parent>
    {
        public Child DoSomething(Child child)
        {
            child.DoSomething(this);
            return child;
        }
    }

    abstract class Child : IChild<Parent> // would be valid, because Parent : IParent<Child>
    {
        public Parent DoSomething(Parent parent)
        {
            parent.DoSomething(this);
            return parent;
        }
    }

[phi1010]

@gafter Updated; finished writing. Can you remove that label again?

[gafter]

See also #311 and #6939.

[gafter]

Also related to #155, #357, #4332, #13397.