Templates and virtual functions

[dsimcha]

Every once in a while, it comes up on this NG that a significant limitation of
templates is that they can't add virtual functions to classes.  Of course,
removing this limitation for the general case is impossible w/o completely
changing the compilation model in ways that are bad ideas for other reasons.
However, would it be reasonable to allow _specific instantiations_ of
templates to add virtual functions?  This might be a nice convenience feature.
 Below is an illustration.

class foo {
    T nothing(T)(T arg) {  // Non-virtual.
        return arg;
    }

    virtual nothing!(int);  // Add nothing!(int) to foo's vtable.
    virtual nothing!(float);  // Add nothing!(float) to foo's vtable.
}

class bar : foo {
    // float, int instantiations override those of foo.
    // Any others are non-virtual and don't override those of foo.
    T nothing(T)(T arg) {
        return 2 * arg;
    }
}

class baz : foo {
    int nothing(int arg) {  // overrides foo.nothing!(int)
        return 3 * arg;
    }

    float nothing(float arg) {  // overrides foo.nothing!(float)
        return 3 * arg;
    }
}

Using the virtual keyword, one could add specific instantiations of a template
to a class's vtable.  Then, these functions would automatically work just like
non-template virtual functions.  My guess (I'm not an expert on compiler
internals) is that this would be easy to implement, yet would help in a lot of
cases where only a few instantiations even make sense.  Of course, the
compiler would throw an error when two instantiations differed only by return
type, just as with non-template functions.