Multidimensional arrays for D

[Denis Shelomovskij]

What does D already have: build-in rectangular static arrays, dynamic 
arrays of arrays, std.range.frontTransversal, std.range.transversal.

Some time ago I was told that "FORTRAN is good for its arrays" and heard 
me saying "it is easy to implement in C++ or D, but in D it will have 
more convenient syntax". But than I have understood that I 
underestimated the problem and it isn't easy to implement in D and looks 
much more harder to implement in C++. In spite of this I decided to 
implement it in D. So, my implementation is ready for test/use but still 
has some TODO-s because it is just a straightforward implementation of 
basic multidimensional array operations with no optimisations. And I 
think it is valuable enough to be added in Phobos in future (tell me if 
it isn't).

Documentation and sources:
http://deoma-cmd.ru/d/docs/src/my/rarray.html

Sources will be at GitHub as soon as I am asked for it.

I have some questions about my array:
* Should such array be a part of Phobos or Druntime?
* Now my array has CT dimensions and RT lengths, should there be a 
version with RT dimensions (or maybe it is the only needed version)?
* Some (or most) of element names should be changed (like 
RectangularArray, because is isn't a rectangular array in the general 
case). So if one knows better names, tell me please (at least 
RectangularArray -> MultidimensionalArray, rectArray -> multiArray?).
* Have I misused some terminology (top dimension etc.)?
* What `Throwable` types should be thrown and when? Currently I use 
`AssertError` for my own mistakes and user incorrect ranges using and 
`Exception` for user incorrect array using, all are in debug mode only.
And I don't understand Druntime exceptions: it uses `Exception` for 
"lengths don't match for array copy" and `core.exception.RangeError` if 
array index is out of bounds and calls it "Range violation" (all are in 
debug mode only). It looks inconsistent.
* For `int a = b / c, d = b % c;` will compiler optimize it or should I 
add there an inline assembly to get `d` from `EDX` on x86 after division?

I also have some questions about other files (my.typetuple and my.traits):
* I was confused with Phobos TypeTuple because it isn't a type tuple. 
Should it be replaced with some modification of my variant?
* Have any additions in my.traits a general use? IMHO ArrayElementType, 
isType and staticRange have.

I also have some ideas (TODO-s) for my array which looks good:
* opSliceAssign with an array or a RectangularArray as its operand 
should use array copy for as much tail dimensions as possible (if data 
has no copy constructor because of dmd bug 6470).
* byElementRandomAccess should also look at all packed tail dimensions 
if they are one dimension for faster indexing.
* Special optimized case for 2^^n-lengths.


Thanks everybody for reading such a big post!