DIP34

DIP34: Static array literals (STILL EDITING -- don't read yet)

Title:	Static array literals
DIP:	34
Version:	1
Status:	Draft
Created:	2013-04-06
Last Modified:	2013-04-06
Author:	Timothee Cour
Links:

Abstract

This is a proposal for introducing static array literals, as follows:

   auto x=[1,2,3]S; 
   static assert(is(typeof(x)==int[3]));

The particular choice of 'S' can be discussed.

Description

Currently, array literals such as

  auto x=[1,2,3];

make x dynamic. To get a static array one needs to write:

  int[3] x=[1,2,3];

which is inconvenient for many reasons:

* DRY principle (need to explicitly write 3 as the length and specify the type

int)

* no easy way to pass a static array litteral to a function accepting a static

array; for example it requires:

  int[3] x=[1,2,3]; 
  fun(x);

Wouldn't it be simple to allow writing array literals using the syntax:

  auto x=[1,2,3]S; 

where S stands for static? More generally the compiler should translate [x1,...,xn]S to: typeof(x1)[n]

Advantages:

* static array litterals becomes as convenient as dynamic ones
* no confusion possible for the compiler; I believe this syntax doesn't clash

with existing syntax.

* In our previous example, no need to write an intermediate x: we can just

write

  fun([1,2,3]S);

or

  fun([1.0,2,3]S); //for example, if static array of doubles requested 

• this would also prevent the common workaround hacks of the form:

  void fun(T...)(T x){} which accept fun(1,2,3): one could just write:
  void fun(T,uint N)(in T[N]x){} or void fun(T,uint N)(T[N]x){}

• this could prevent inefficient intermediate code as reported in Issue 2356

and related, as it would be clear from "S" that a static is requested.

• this could be used in expressions as well: auto x=[1,2,3]S+[4,5,6]S;

This should be simpler than a previous request I've seen for int[$]x=[1,2,3];, which still requires one to write the type explicitly.

Copyright

This document has been placed in the Public Domain.