Array types

[Norbert Nemec]

Yippie-yeah! My favorite topic is being mentioned! I have to give a 
comment... :-)

On 26/08/10 22:38, bearophile wrote:
 > [...]
> So far in D code I have had need of (and I have seen some people need) some other kinds of arrays, not (well) supported by D:
> C) nD rectangular dynamic arrays;
> [...]
> The (C) arrays are not the same thing as dynamic arrays of dynamic arrays because:
> - Some algorithms are not designed for a triangle where rows may differ in length. Testing that rows are all the same length at runtime wastes time, and if you don't test it then it may cause bugs;
> - Sometimes you want to reshape a 2D matrix, so it's useful to store the matrix in contiguous memory;
> - Sometimes you need complex slicing, for example removal of some columns and rows from a 2D matrix.
>
> Recently in D.learn we have discussed this a bit.
>
> In C# there are both arrays of arrays as in D, and rectangular dynamic arrays, that are manages with a syntax similar to Pascal arrays: arr[x,y,z]. I think there is no so need to put them into D. But I think it's important to have a official type of them in Phobos, for example implemented as a struct (only the item type and number of dimensions are known at compile time):
>
> RectangularArray!(T, int ndimensions)

I still have my doubt that rectangular arrays can be implemented to full 
power in the library. Currently, there is a number of essential 
languages missing to allow a sane syntax:

* ranges 'A..B' as standalone expression
* following from this: replacement of opSlice by opIndex overloaded for 
builtin type of range expression
* extension of range expression by stride (e.g. 'A..B:C' )
* handling of opDollar '$' for multiple dimensions

Beyond this, there are a few issues where I don't see that a 
library-based solution will ever have the full power of a builtin 
language feature:

* array expressions with clean and easy to use syntax
* syntax of type declarations: double[A,B] for static arrays and 
something like double[[3]] or double[:,:] for dynamic arrays are just 
far more straightforward and readable than any template-based syntax I 
could imagine.

Ultimately, I think that rectangular arrays are as fundamental of 
numerical computing as hash-maps and strings for other areas. Moreover, 
there is a huge number of physicists working with Fortran95 simply 
because it is about as simple to use as Basic, without classes, let 
alone templates. The mere thought of having to touch classes or 
templates would deter many of them to consider D an option.