Function templates do implicit conversions for their arguments

Maxim Fomin maxim at maxim-fomin.ru
Thu Jul 4 12:44:03 PDT 2013


On Thursday, 4 July 2013 at 19:00:51 UTC, TommiT wrote:
>> Note, that T is Toy, so there were no type conversion during 
>> template instantiation. There was argument conversion after 
>> instantiation, as it happens usually. Back to foo function 
>> accepting slice - dmd does the same thing.
>
> DMD doesn't do the same thing for static arrays. Due to alias 
> this, your Toy is a Wrap!Toy for all intents and purposes. 
> There's no is-a relationship between a static array type and 
> the dynamic array type which it implicitly converts to. What 
> happens when static array implicitly converts to dynamic array 
> is the same type of implicit conversion which happens when long 
> converts to double. There's no is-a relationship between long 
> and double.

The idea that situation with alias this and arrays is 
functionally different is simply defeacted by

static assert (is(int[1] : int[]));
static assert (is(Toy : Wrap!Toy));
static assert (!is(int[1] == int[]));
static assert (!is(Toy == Wrap!Toy));

>> See above. What type implicit converision did dmd in case of 
>> int[10] and int[]. Conversion from int to int?
>
> Here's what the compiler does during type deduction when it 
> sees the following function template and its instantiation:
>
> void foo(T)(T[] da) { }
>
> int[10] sa;
> foo(sa);
>
> <steps follow ...>

This is nice and interesting to read. Please provide references 
to dmd code which support the description of dmd compiling 
process you provided (judging by how confident in this topic you 
are, you might have studied cast.c, expression.c and template.c 
wery well). Without such references any text pretending to tell 
something about what compiler does is cheap.


More information about the Digitalmars-d mailing list