C# Proposal: Compile Time Static Checking Of Dynamic Objects

class A {
   public virtual A F();
}
class B : A {
   public override B F();
}

class A {
   public virtual A F();
   public virtual B F();
}
class B : A {
   public override C F();
}
class C : B {}

interface I<out T>
{
    T F();
}
 
class A : I<A>
{
    public virtual A F() { return new A(); }
}
 
class B : A, I<B>
{
    public virtual B F() { return new B(); }
}

var a = new B();
Console.WriteLine(a.GetType());
Console.WriteLine(a.F().GetType());

public virtual A Convert(A from) { ... }

A a = new B();
Console.WriteLine(a.F().GetType());

Would you also expect your type to be both covariant on the output value and contravariant on the input value?

You would have to choose just one variance type.

Can you provide code samples for what you are proposing as extension types?

As for your Zap method, although valid for the compiler, it is not recommended to use extension methods on null instances because the same method might be added on a future version of the extended type and it might break recompiled code. Something like String.IsNullOrEmpty should never e an extension method - although I've advocated that myself in the past.

Paulo Morgado wrote:

Can you provide code samples for what you are proposing as extension types?

Extension xStringBuilder
  Extends System.Text.StringBuilder
 
  Public Property Value() As String
    Get
      Return Me.ToString
    End Get
    Set(ByVal Value as String)
      Me.Length = 0
      Me.Append(Value)
    End Set
  End Property
 
  Public Sub Clear
    Me.Length=0
  End Sub
End Extension
 
Extension xDisposable
  Extends iDisposable
 
  Public Shared Sub Dispose(ByVal Shared Self As xDisposable)
    ' Note the following cast will always be valid, and the compiler
    ' will know this; no need for a run-time check.
    If Self isNot Nothing then Ctype(Self,iDisposable).Dispose
  End Sub
End Extension
 
Extension xZap(of T)
  Extends T
 
  Public Shared Sub Dispose(ByVal Shared Self as xZap(of T))
    If Self IsNot Nothing Then
      Dim Thing As iDisposable = TryCast(Self, iDisposable)
      If Thing IsNot Nothing Then Thing.Dispose
    End Thing
  End Sub
End Extension

Paulo Morgado wrote:

As for your Zap method, although valid for the compiler, it is not recommended to use extension methods on null instances because the same method might be added on a future version of the extended type and it might break recompiled code.

So, if I understand you correctly, what you are in fact proposing is some type of runtime subtyping of instances.

This would be true: typeof(StringBuilder).IsAssignableFrom(typeof(xStringBuilder))

And there would always be an explicit cast between StringBuilder and xStringBuilder.

Is that it?

Apart the fact that there aren’t extension properties (now), what do you get out of it that you don’ get out of extension methods?

Paulo Morgado wrote:

So, if I understand you correctly, what you are in fact proposing is some type of runtime subtyping of instances.

Paulo Morgado wrote:

Extension methods are normal static methods where the first parameter is the extended type. You can always call that explicitly (that's what the compiler does), if you want to.