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

On Thursday, 18 July 2013 at 19:11:55 UTC, H. S. Teoh wrote:
> 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. :))
>
>


You did it again! Thanks for the accurate and details response! I don't mind there being a difference between T and alias T as long as I know what it is ;) (although it does require two templates do deal with both cases and can increase template explosion).

Thank again.