Jump to page: 1 2
Thread overview
[Issue 13556] inconsistent 'new' syntax for arrays
Sep 29, 2014
Ketmar Dark
Oct 02, 2014
Kenji Hara
Nov 09, 2014
Stewart Gordon
Nov 09, 2014
Ketmar Dark
May 30, 2015
Ketmar Dark
Dec 17, 2022
Iain Buclaw
September 29, 2014
https://issues.dlang.org/show_bug.cgi?id=13556

bearophile_hugs@eml.cc changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |bearophile_hugs@eml.cc

--- Comment #1 from bearophile_hugs@eml.cc ---
I suspect that the array creation syntax is an unfixable mess.

new int[256][256] can also be generate a pointer to fixed size array int[256][256].

--
September 29, 2014
https://issues.dlang.org/show_bug.cgi?id=13556

Ketmar Dark <ketmar@ketmar.no-ip.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |ketmar@ketmar.no-ip.org

--- Comment #2 from Ketmar Dark <ketmar@ketmar.no-ip.org> ---
(In reply to bearophile_hugs from comment #1)
> I suspect that the array creation syntax is an unfixable mess.
> 
> new int[256][256] can also be generate a pointer to fixed size array int[256][256].
this can be easily fixed: `new [256][256]` => `new [][](256, 256)`, and `new
([256])[256]` => `new [256][](256)`.

i.e. to generate array of 256 `ubyte[256]` one can add parens. this way `[256][256]` will be intuitive and '256*ubyte[256]' is possible.

or just kill then `new [n]` syntax altogether, so people will not try `new [n][m]`.

--
October 02, 2014
https://issues.dlang.org/show_bug.cgi?id=13556

--- Comment #3 from Kenji Hara <k.hara.pg@gmail.com> ---
(In reply to bearophile_hugs from comment #1)
> I suspect that the array creation syntax is an unfixable mess.
> 
> new int[256][256] can also be generate a pointer to fixed size array int[256][256].

I think all dynamic array allocation should be writtten as:

    int[][](1, 2)

Current ambituity syntax new int[2][1] should be deprecated, removed, and then we can reuse it for static array allocation.

--
October 02, 2014
https://issues.dlang.org/show_bug.cgi?id=13556

--- Comment #4 from bearophile_hugs@eml.cc ---
(In reply to Kenji Hara from comment #3)

> Current ambituity syntax new int[2][1] should be deprecated, removed, and then we can reuse it for static array allocation.

I suggest you to make you usual long table of all possible combinations, to show me what to allow and what to deprecate :-) If we manage to improve the array creation syntax it's going to be a significant improvement for D, because I use arrays all the time.

--
November 09, 2014
https://issues.dlang.org/show_bug.cgi?id=13556

Stewart Gordon <smjg@iname.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |smjg@iname.com

--- Comment #5 from Stewart Gordon <smjg@iname.com> ---
(In reply to Ketmar Dark from comment #0)
> this is accepted by DMD:
> 
>   int[] a0 = new int[256];
> 
> and this is not:
> 
>   int[][] a1 = new int[256][256];

This isn't meant to work.  int[][] is a dynamic array of dynamic arrays, not a rectangular array.  That is, it's a (length, pointer) tuple, which points to the elements each of which is a (length, pointer) tuple.

On the other hand, new int[256][256] is of type int[256][] - a dynamic array of static arrays.

(In reply to Kenji Hara from comment #3)
> Current ambituity syntax new int[2][1] should be deprecated, removed, and then we can reuse it for static array allocation.

What exactly are you wanting that's different from what it already does?

--
November 09, 2014
https://issues.dlang.org/show_bug.cgi?id=13556

--- Comment #6 from Ketmar Dark <ketmar@ketmar.no-ip.org> ---
(In reply to Stewart Gordon from comment #5)
i understand why it's not working as one expecting. but i'm talking about
"principle of least astonishment" (ah, this is sore spot of D…).

people are not computers. my common sense tells me that if `int[] a0 = new int[256];` works by creating 256-element array of ints, then ` int[][] a1 = new int[256][256];` should create 256x256 element matrix. but D is constantly fighting with common sense, i'm starting to get used to this. ;-)

--
May 30, 2015
https://issues.dlang.org/show_bug.cgi?id=13556

dennis.m.ritchie@mail.ru changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |dennis.m.ritchie@mail.ru

--- Comment #7 from dennis.m.ritchie@mail.ru ---
(In reply to Kenji Hara from comment #3)
> (In reply to bearophile_hugs from comment #1)
> > I suspect that the array creation syntax is an unfixable mess.
> > 
> > new int[256][256] can also be generate a pointer to fixed size array int[256][256].
> 
> I think all dynamic array allocation should be writtten as:
> 
>     int[][](1, 2)
> 
> Current ambituity syntax new int[2][1] should be deprecated, removed, and then we can reuse it for static array allocation.

Now D is used for a multidimensional array syntax :)

auto arrray = new int[][][][][][][][][][][](4, 8, 6, 13 /* ... The length of the other subarrays on request */);

I suggest to implement such a syntax for declaring multidimensional arrays:

auto array = new int[11](4, 8, 6, 13 /* .... The length of the other subarrays
on request */);

P.S. The syntax for declaring multidimensional arrays, needs work!

--
May 30, 2015
https://issues.dlang.org/show_bug.cgi?id=13556

--- Comment #8 from dennis.m.ritchie@mail.ru ---
> Current ambituity syntax new int[2][1] should be deprecated, removed, and then we can reuse it for static array allocation.

Quickly already, the problems with static arrays in D are boring.

--
May 30, 2015
https://issues.dlang.org/show_bug.cgi?id=13556

--- Comment #9 from Ketmar Dark <ketmar@ketmar.no-ip.org> ---
(In reply to dennis.m.ritchie from comment #7)
> I suggest to implement such a syntax for declaring multidimensional arrays:
> 
> auto array = new int[11](4, 8, 6, 13 /* .... The length of the other
> subarrays on request */);

you can do almost the same with templates.

auto DNew(T, A...) () if (A.length > 0) {
  template A2S(A...) {
    import std.conv : to;
    static if (A.length == 0)
      enum A2S = "";
    else
      enum A2S = to!string(A[0])~","~A2S!(A[1..$]);
  }
  import std.array : replicate;
  return mixin("new "~T.stringof~"[]".replicate(A.length)~"("~A2S!A~")");
}


void main () {
  import std.stdio;
  auto a = DNew!(int, 5, 6, 7);
  a[2][3][4] = 42;
  writeln(a[2][3][]);
}

--
May 31, 2015
https://issues.dlang.org/show_bug.cgi?id=13556

--- Comment #10 from dennis.m.ritchie@mail.ru ---
(In reply to Ketmar Dark from comment #9)
> (In reply to dennis.m.ritchie from comment #7)
> > I suggest to implement such a syntax for declaring multidimensional arrays:
> > 
> > auto array = new int[11](4, 8, 6, 13 /* .... The length of the other
> > subarrays on request */);
> 
> you can do almost the same with templates.
> 
> auto DNew(T, A...) () if (A.length > 0) {
>   template A2S(A...) {
>     import std.conv : to;
>     static if (A.length == 0)
>       enum A2S = "";
>     else
>       enum A2S = to!string(A[0])~","~A2S!(A[1..$]);
>   }
>   import std.array : replicate;
>   return mixin("new "~T.stringof~"[]".replicate(A.length)~"("~A2S!A~")");
> }
> 
> 
> void main () {
>   import std.stdio;
>   auto a = DNew!(int, 5, 6, 7);
>   a[2][3][4] = 42;
>   writeln(a[2][3][]);
> }

Yes, do that D is really easy!

Then why in the D still has not gotten rid of this hardcore syntax :)

auto a = new int[][][](5, 6, 7);

Surely this is an attempt to maintain compatibility with C?

--
« First   ‹ Prev
1 2