foreach over split string

[JS]

Since you do such a good job a explaining things, would you mind 
informing me what the difference between alias T, T and string T 
used as template parameters are?

template A!(T) { }
template A!(alias T) { }
template A!(string T) { }


The string version is suppose to be a specialization of A that is 
called when A is passed a string? e.g., A!("...") calls the 
string version? (this is my assumption but I seem to run into 
problems where sometimes other versions are called)

The alias T version seems to accept a symbol alias(a sort of 
redirection/substitution is made but no actual evaluation is made 
on the symbol).

The T version accepts types and compile type 
constants/literals(like a string).


This is what I understand them to do... but always get into 
trouble where something wants an alias while another thing wants 
a type.

moduleName complains a lot because sometimes I pass it a built in 
type like double , sometimes a string(by accident but I want it 
to return the string itself), and sometimes I pass a user type.

I have to rectify all 3 usages into one common template so I wrap 
moduleName into, say ModuleName.

template ModuleName(T) { return (isBasicType!T) ? "" : 
moduleName!(T); }
template ModuleName(string s) { return s; }

but sometimes, it seems the T version is called when I pass it a 
string.

Error: template instance moduleName!(string) does not match 
template declaration moduleName(alias T)

when I use

template ModuleName(T)
{
     static if (isValueType!T)
         enum ModuleName = "";
     else static if (isString!T)
         enum ModuleName = T;
     else
         enum ModuleName = StripStr!(std.traits.moduleName!T, `"`, 
" ");
}

template ModuleName(string s) { enum ModuleName = s; }

StripStr is just a template that strips the ends of a string. 
isValueType is a template wrapper to test T for a value 
type(scalar, void, string... *all* types that do not have/need 
module resolution)

The error suggests that I'm passing a string into the 
std.traits.moduleName call but this shouldn't happen?