Difference between revisions of "DIP34"

From D Wiki
Jump to: navigation, search
Line 37: Line 37:
 
== Description ==
 
== Description ==
 
Currently, array literals such as  
 
Currently, array literals such as  
 +
<syntaxhighlight lang="d">
 
   auto x=[1,2,3];
 
   auto x=[1,2,3];
 +
</syntaxhighlight>
 
make x dynamic. To get a static array one needs to write:  
 
make x dynamic. To get a static array one needs to write:  
 +
<syntaxhighlight lang="d">
 
   int[3] x=[1,2,3];
 
   int[3] x=[1,2,3];
 +
</syntaxhighlight>
 
which is inconvenient for many reasons:
 
which is inconvenient for many reasons:
  * DRY principle (need to explicitly write 3 as the length and specify the type
+
  * it's not DRY (need to explicitly write 3 as the length and specify the type int)
int)
+
  * there's no easy way to pass a static array literal to a function accepting a static array; for example it requires:
  * no easy way to pass a static array litteral to a function accepting a static
+
<syntaxhighlight lang="d">
array; for example it requires:
 
 
   int[3] x=[1,2,3];  
 
   int[3] x=[1,2,3];  
 
   fun(x);
 
   fun(x);
 +
</syntaxhighlight>
  
 
+
Instead we propose the syntax:
Wouldn't it be simple to allow writing array literals using the syntax:
+
<syntaxhighlight lang="d">
 
   auto x=[1,2,3]S;  
 
   auto x=[1,2,3]S;  
where S stands for static?
+
</syntaxhighlight>
More generally the compiler should translate [x1,...,xn]S to: typeof(x1)[n]
+
where S stands for static. More generally the compiler should translate
 +
<syntaxhighlight lang="d">
 +
[x1,...,xn]S to: typeof(x1)[n]
 +
</syntaxhighlight>
  
 
Advantages:
 
Advantages:
  * static array litterals becomes as convenient as dynamic ones
+
  * static array literals becomes as convenient as dynamic ones
  * no confusion possible for the compiler; I believe this syntax doesn't clash
+
  * no confusion possible for the compiler; I believe this syntax doesn't clash with existing syntax.
with existing syntax.
+
  * In our previous example, no need to write an intermediate x: we can just write
  * In our previous example, no need to write an intermediate x: we can just
+
<syntaxhighlight lang="d">
write
 
 
   fun([1,2,3]S);
 
   fun([1,2,3]S);
or
 
 
   fun([1.0,2,3]S); //for example, if static array of doubles requested  
 
   fun([1.0,2,3]S); //for example, if static array of doubles requested  
 +
</syntaxhighlight>
  
 
* this would also prevent the common workaround hacks of the form:
 
* this would also prevent the common workaround hacks of the form:
 +
<syntaxhighlight lang="d">
 
   void fun(T...)(T x){} which accept fun(1,2,3): one could just write:
 
   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){}
 
   void fun(T,uint N)(in T[N]x){} or void fun(T,uint N)(T[N]x){}
 +
</syntaxhighlight>
  
* this could prevent inefficient intermediate code as reported in Issue 2356
+
* 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.  
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 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];,
+
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.
which still requires one to write the type explicitly.
 
  
 
== Copyright ==
 
== Copyright ==

Revision as of 07:58, 10 November 2013

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:

* it's not DRY (need to explicitly write 3 as the length and specify the type int)
* there's no easy way to pass a static array literal to a function accepting a static array; for example it requires:
   int[3] x=[1,2,3]; 
   fun(x);

Instead we propose 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 literals 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);
   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.