Excuse me, because I haven't been active in the D community the last
year due to school concerns. However, I have been fiddling with the
language and on this newsgroups since 2001.
As I understand it, dynamic arrays are going away soon in D2.0 in
favor of an ArrayBuilder class.
I don't like it at all. I want to stomp my feet and throw a temper
tantrum. As far as I am concerned, T[] has always been an
array-builder. Now, I'd appreciate some considering, and that you'll
excuse my poor phrasing when it comes to terminology (I am not a
trained computer scientist).
For the last 9 years there has been problems with dynamic arrays.
Now, I intend to enumerate the problems I have encountered and propose
some solutions, but let me first describe the internals of the D Arrays
as I understand them: (To simplify)
struct Array(T) {
T* ptr;
uint length;
}
So, D basically wraps this with various syntatic sugar. Now, there
have been a variety of probelsm with using this same type for dynamic
arrays:
1) It has failed as an array builder because it does not contain the
length of the memory it references AS WELL as the actually number of
elements stored. Thus cannot do pre-allocation like vector<> in
C++STL without some GC magic. This make it slow to append.
1-Solution) So, add an additional real_length parameter to dynamic arrays.....
2) If you take a slice, it often doesn't behave as expected.
Implement a new type T[..] that are specifically slices of other
arrays. This will add another parameter that references the array
the slice came from. Thus, appending to a slice can behave as an
insertion into it's parent and other syntatic niceties.
2-Solution) I propose that this type Arr[..] would be implicitely
castable to other array types, at the expense of a dup.
3) If dynamic arrays are passed, they pass the aformentioned struct
"by-value." This however results in the ptr NOT being shared by the
function and its caller. So, if a receiving function tries to append
to them it is possible that the sender doesn't notice the array has
been moved by the memory manager.
3-Solution) So, since static arrays are now pass-by-value. Make this
true for dynamic arrays also, and provide a warning of some sort.
This would give you the expected read-only sematics of passing values
instead of the C one where [] == *. Instead the proper way to pass a
read-write dynamic array would be by reference (AKA a Handle ...
Computer Scientists solved this problem along time ago:
http://en.wikipedia.org/wiki/Handle_%28computing%29 ). Now, this
causes some overhead in terms fo double look-ups for classes which
might not need to change the pointer address -- maybe there is some way
around doing this also though?
********* Did I miss anything? Maybe my solutions are incomplete?
Please comment and revise this. I think it would be a shame to get
rid of the syntatic sugar of dynamic arrays in support of an
ArrayBuilder class/struct.
-S.
