Is there a "nice" way to access the names of template parameters outside?

[Lukas Borin]

Consider the following template

```D
auto foo(T, int W, int H)(T p1, T p2) { }
```

Is there a "nice" way from the outside the get the names of the 
template values?

E.g:
```D
pragma(msg, TemplateParameterNames!(foo)); // AliasSeq!("T", "W", 
"H") or ["T", "W", "H"]
```

I know you can find the names values in a very hacky way. 
(atleast in dmd 2.097.1)

```D
template HackyHack(alias T) {
    enum RawName = T.stringof;
    enum HackyHack = parseRawName(RawName); // Or 
templateParse!RawString;
}

```

I currently have the HackyHack solution *"working"* but I really 
don't like it and I would be supprised if it works on other dmd 
version or other compilers.


I know I can do things like:

```D
template foo(T, int W, int H) {
    enum names = ... // some magic with __traits or just assing it 
to ["T", "W", "H"]
    auto foo(T p1, T p2) { }
}
```

Use template mixins or other solutions to get what I want but if 
possible I prefer to just introspect on the template.

Usecase right now is to do some cuda kernel generation from a D 
shortfunction.

Something like this:

```D
@kernel
auto saxpy(T, int Iters, int N, int Stride)(T a, T* x, T* y, T* 
output) => q{
     int tid = blockIdx.x * blockDim.x + threadIdx.x;
     for(int idx = tid, int i = 0; i < Iters && idx < N; ++i, idx 
+= Stride) {
         output[idx] = a * x[idx] + y[idx];
     }
};
```

Would get transformed to:
```D
template<typename T, int Iters, int N, int Stride>
__global__ void saxpy(T a, T* x, T* y, T* output) {
     //Identical function body / parameters and template arguments 
from the @kernel
     //D function.
     int tid = blockIdx.x * blockDim.x + threadIdx.x;
     for(int idx = tid, int i = 0; i < Iters && idx < N; ++i, idx 
+= Stride) {
         output[idx] = a * x[idx] + y[idx];
     }
}
```

Really need the names to make this translation, correctly.

Just to be clear i'm not interested in getting the arguments a 
template was instantiated with. I can use TemplateArgsOf!T for 
that.