Preserving const? -- A potential solution

[Tim M]

Firstly option 2 was just crazy and I don't know why you said that. For  
option 1 you identifying the limitations and are just trying to apply as  
many problems as you can though the main barriers can easily be lowered.

As you already know templates are a compile time feature, so that  
statement about the compiler needs to every possible call doesn't make  
that much sense, the template inference works only for compile time type  
recognition and that is all that my sample code I posted used:



import std.stdio;

class A
{
       char[] name;
       this()
       {
             name = "A".dup;
       }
       T max(T)(T a, T b)
       {
             writefln(name ~ "- A.max()");
             return a > b ? a : b;
       }

}

class B : A
{
       this()
       {
             name = "B".dup;
       }
       T max(T)(T a, T b)
       {
             writefln(name ~ "- B.max()");
             return a > b ? a : b;
       }
}


void main()
{
       A b = new B();
       invariant int i = 2;
       invariant int j = 4;
       auto k = b.max(i,j); //invariant int is the only template compiled in

}

This code when run will print: B- A.max()

It is still a "B" but compiler can only see the "A.(T)max(T,T)" being  
called. What can actually be computed by the compiler is that another  
member function with the same exact signature exists in one or more  
subclasses. With this knowledge it can compile the "max" template as it  
did with "A" for all it's subclasses and insert the runtime type checking  
to decide which of them to call.

So just to help clarify the template is not instantiated in different ways  
but the same instantiation is done for each compatible class function.

The example currently compiles in:

A.max(invariant int)()

I am suggesting to compile in:

A.max(invariant int)()
B.max(invariant int)()
//any other subclasses

+ runtime type checking