Templating Function Names

[Bryce Kellogg via Digitalmars-d-learn]

Say I've got a bunch of classes that inherit from a common 
interface (in this case Component) and a class Foo that can 
handle any subclass of Component. Like so:

interface Component { ... }
class A : Component { ... }
class B : Component { ... }
class C : Component { ... }

class Foo {
     alias a = this.of!A;
     alias b = this.of!B;
     alias c = this.of!C;
     void of(T : Component)(T t) { ... }
}

It's pretty trivial to access a specific component using regular 
templates:

     f.of!A = new A();
     f.of!B = new B();
     f.of!C = new C();

And I can alias the instantiations of these templates as seen 
above for a cleaner interface:

     f.a = new A();
     f.b = new B();
     f.c = new C();

However, suppose I have the following situation:

void main() {
     Foo f = new Foo();
     class D : Component { ... }

     f.of!D = new D(); // works fine
     f.d = new D();    // fails to compile (for obvious reason)
}

Is there a way I can get a function of Foo named after D (like 
f.d() or f.D()) without knowing before hand every single subclass 
of Component and adding aliases manually?

For example, is there a way to template the name of the function 
or an alias like:

void T(T : Component)(T t) { ... }
or
alias T = this.of!T;

Both of these just gave me functions named T.

The important thing is that it's transparent to the person 
creating a new subclass of Component. It should look like Foo 
always had a property named after their custom Component.

Is this possible?

Thanks!
Bryce