foreach over split string

[H. S. Teoh]

On Thu, Jul 18, 2013 at 12:07:58PM +0200, JS wrote:
> 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) { }

T here is a type name. So you can pass in 'int', 'string', etc., or any
user-defined type.


> template A!(alias T) { }

T here is a "symbol", that is, the name of a variable, or a function
literal, etc. Basically an entry in the compiler's symbol table.


> template A!(string T) { }
[...]

T here is a string value. So either a string literal or a string value
known at compile-time. Note that this should not be confused with the
string *type*. That is:

	A!("abc")	// matches template A!(string T)
	A!(string)	// matches template A!(T)

It's probably not a good idea to overload a template on an alias
parameter *and* a string parameter, though, because alias can refer to
*any* symbol, including string literals. You'll either get an ambiguity
error, or the compiler may do something unexpected.

You're probably asking what "any symbol" includes. Perhaps this code
might be enlightening:

	template Templ(alias A) {
		pragma(msg, typeof(A));
		enum Templ = 1;
	}

	void main() {
		int x;
		int delegate(int x) dg;

		auto dummy1 = Templ!("a");
		auto dummy2 = Templ!(x);
		auto dummy3 = Templ!((int z) => z*2);
		auto dummy4 = Templ!(dg);
		auto dummy5 = Templ!(123);

		// Compile error: types are not symbols, so they won't
		// match the alias parameter:
		//auto dummy6 = Templ!(int);
	}

The compiler output is:

	string
	int
	int function(int z) pure nothrow @safe
	int delegate(int x)
	int

That is to say, "alias A" picked up everything ranging from local
variables to string literals to function literals. The only thing it
didn't pick up is types.

(As to *why* alias parameters behave in this way and why that might be
useful, that's a whole 'nother topic. :))


T

-- 
Everybody talks about it, but nobody does anything about it!  -- Mark Twain