I suspect I'm being very dumb here, but I can't get my head around this:

    template B(alias A)
    {
	alias B = A;
    }
    template C(A ...)
    {
	alias C = A[0];
    }
    static assert(B!1 == 1); //fine
    static assert(C!1 == 1); //Error: cannot alias an expression 1

On Monday, 21 October 2013 at 12:58:55 UTC, John Colvin wrote:
> I suspect I'm being very dumb here, but I can't get my head around this:
>
>     template B(alias A)
>     {
> 	alias B = A;
>     }
>     template C(A ...)
>     {
> 	alias C = A[0];
>     }
>     static assert(B!1 == 1); //fine
>     static assert(C!1 == 1); //Error: cannot alias an expression 1

I think this is a good match for a gold collection of "awkward mismatch of template alias vs normal alias". I am quite surprised former template work actually, aliases are not supposed to handle expressions at all. But magic of template alias parameter turns expression into symbol and here we go.

On Monday, 21 October 2013 at 15:00:26 UTC, Dicebot wrote:
> On Monday, 21 October 2013 at 12:58:55 UTC, John Colvin wrote:
>> I suspect I'm being very dumb here, but I can't get my head around this:
>>
>>    template B(alias A)
>>    {
>> 	alias B = A;
>>    }
>>    template C(A ...)
>>    {
>> 	alias C = A[0];
>>    }
>>    static assert(B!1 == 1); //fine
>>    static assert(C!1 == 1); //Error: cannot alias an expression 1
>
> I think this is a good match for a gold collection of "awkward mismatch of template alias vs normal alias". I am quite surprised former template work actually, aliases are not supposed to handle expressions at all. But magic of template alias parameter turns expression into symbol and here we go.

I didn't know the B template would work... Is this correct semantics according to the spec?

On Monday, 21 October 2013 at 16:51:02 UTC, simendsjo wrote:
> I didn't know the B template would work... Is this correct semantics according to the spec?

http://dlang.org/template.html#TemplateAliasParameter
"Literals can also be used as arguments to alias parameters."

On Monday, 21 October 2013 at 12:58:55 UTC, John Colvin wrote:
> I suspect I'm being very dumb here, but I can't get my head around this:
>
>     template B(alias A)
>     {
> 	alias B = A;
>     }
>     template C(A ...)
>     {
> 	alias C = A[0];
>     }
>     static assert(B!1 == 1); //fine
>     static assert(C!1 == 1); //Error: cannot alias an expression 1

I say file it as a bug. That will make for an official answer on what is correct. Could be that template B shouldn't be valid either.

On Monday, 21 October 2013 at 12:58:55 UTC, John Colvin wrote:
> I suspect I'm being very dumb here, but I can't get my head around this:
>
>     template B(alias A)
>     {
> 	alias B = A;
>     }
>     template C(A ...)
>     {
> 	alias C = A[0];
>     }
>     static assert(B!1 == 1); //fine
>     static assert(C!1 == 1); //Error: cannot alias an expression 1

Also:

    struct S{}

    template B(alias A)
    {
        alias B = A;
    }
    template C(A ...)
    {
        alias C = A[0];
    }
    pragma(msg, B!int); //Error: template instance B!(int)
          //does not match template declaration B(alias A)
    pragma(msg, B!S); // S
    pragma(msg, C!int); // int
    pragma(msg, C!S); // S

On Monday, 21 October 2013 at 18:42:27 UTC, John Colvin wrote:
> On Monday, 21 October 2013 at 12:58:55 UTC, John Colvin wrote:
>> I suspect I'm being very dumb here, but I can't get my head around this:
>>
>>    template B(alias A)
>>    {
>> 	alias B = A;
>>    }
>>    template C(A ...)
>>    {
>> 	alias C = A[0];
>>    }
>>    static assert(B!1 == 1); //fine
>>    static assert(C!1 == 1); //Error: cannot alias an expression 1
>
> Also:
>
>     struct S{}
>
>     template B(alias A)
>     {
>         alias B = A;
>     }
>     template C(A ...)
>     {
>         alias C = A[0];
>     }
>     pragma(msg, B!int); //Error: template instance B!(int)
>           //does not match template declaration B(alias A)

Alias doesn't take primitive types. I usually add a regular B(A) template overload too. Note that when you have a alias A overload, structs uses that rather than the basic A template.

>     pragma(msg, B!S); // S
>     pragma(msg, C!int); // int
>     pragma(msg, C!S); // S

Please check the specification I have linked ;) It is a weird design but implementation currently conforms to it.

On Monday, 21 October 2013 at 16:51:02 UTC, simendsjo wrote:
> On Monday, 21 October 2013 at 15:00:26 UTC, Dicebot wrote:
>> On Monday, 21 October 2013 at 12:58:55 UTC, John Colvin wrote:
>>> I suspect I'm being very dumb here, but I can't get my head around this:
>>>
>>>   template B(alias A)
>>>   {
>>> 	alias B = A;
>>>   }
>>>   template C(A ...)
>>>   {
>>> 	alias C = A[0];
>>>   }
>>>   static assert(B!1 == 1); //fine
>>>   static assert(C!1 == 1); //Error: cannot alias an expression 1
>>
>> I think this is a good match for a gold collection of "awkward mismatch of template alias vs normal alias". I am quite surprised former template work actually, aliases are not supposed to handle expressions at all. But magic of template alias parameter turns expression into symbol and here we go.
>
> I didn't know the B template would work... Is this correct semantics according to the spec?

I've used quite some T(A...), so I was used to literals not being aliasable.
A bit strange that literals "is symbols" (or how I should phrase it) when using T(alias A), but not T(A...).

On Monday, 21 October 2013 at 16:51:02 UTC, simendsjo wrote:
> On Monday, 21 October 2013 at 15:00:26 UTC, Dicebot wrote:
>> On Monday, 21 October 2013 at 12:58:55 UTC, John Colvin wrote:
>>> I suspect I'm being very dumb here, but I can't get my head around this:
>>>
>>>   template B(alias A)
>>>   {
>>> 	alias B = A;
>>>   }
>>>   template C(A ...)
>>>   {
>>> 	alias C = A[0];
>>>   }
>>>   static assert(B!1 == 1); //fine
>>>   static assert(C!1 == 1); //Error: cannot alias an expression 1
>>
>> I think this is a good match for a gold collection of "awkward mismatch of template alias vs normal alias". I am quite surprised former template work actually, aliases are not supposed to handle expressions at all. But magic of template alias parameter turns expression into symbol and here we go.
>
> I didn't know the B template would work... Is this correct semantics according to the spec?

I've used quite some T(A...), so I was used to literals not being
aliasable.
A bit strange that literals "is symbols" (or how I should phrase
it) when using T(alias A), but not T(A...).