Static arrays, typeof and IFTI?

[kennytm]

Norbert Nemec <Norbert at Nemec-online.de> wrote:
> Hi there,
> 
> after a very busy and eventful year in my personal life, I have now
> finally found some time to play with D2. I am very impressed by the
> progress!
> 
> One thing I noticed was that static arrays are somehow strangely limited:
> 
> It is possible to overload based on the length:
> 
> --------
> void f(int[3] x) {
>    writeln("int[3]: ",x);
> }
> 
> void f(int[4] x) {
>    writeln("int[4]: ",x);
> }
> 
> int main(string argv[]) {
>    f([1,2,3]);
>    f([1,2,3,4]);
>    return 0;
> }
> --------
> 
> However, used as function template argument, a static array is casted to
> a dynamic array:
> 
> -----------
> void g(T)(T x) {
>    static assert (__traits(isStaticArray,T));
>    enum N = T.init.length;
>    writeln(N,": ",x);
> }
> 
> int main(string argv[]) {
>    g([1,2,3]);
>    return 0;
> }
> ------------
> 
> gives the error message:
> 
> |  Error: static assert  (__traits(isStaticArray,int[])) is false
> |         instantiated from here: g!(int[])
> 
> Without the assertion, N is defined to 0.
> 
> Further investigation shows:
> 
> -------
> 	g!(int[3])([1,2,3]);  // passes a static array
> -------
> 	int[3] x3 = [1,2,3];
> 	g(x3);                // passes a static array
> -------
> 	auto z3 = [1,2,3];    // defines z3 as dynamic array
> 	g(y3);                // passes a dynamic array
> -------
> 
> So it seems, the problem is that array literals on their own turned into
> dynamic arrays unless you explicitly state a static array type in some way.
> 
> Wouldn't it make more sense the other way around? After all, turning a
> static array into a dynamic array is easy, the other way around is
> prohibited by the compiler. If array literals simply had a static array
> type, they could be implicitly casted to dynamic arrays when necessary
> but stay static if possible.
> 
> Greetings,
> Norbert

I think you could use something like

    void f(T, size_t n)(T[n] param) { ... }

(not tested)