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