Dynamic arrays in D 1.0

[Edward Diener]

Bill Baxter wrote:
> Edward Diener wrote:
>> In D 1.0 dynamic arrays are the equivalent of C++'s std::vector<T>, 
>> with slicing replacing iterators in order to access some subrange of 
>> the sequence. In C++ there is functionality in std::vector::erase for 
>> erasing elements from the vector and std::vector::insert for inserting 
>> new elements into the vector. Where is that functionality in D's 
>> dynamic arrays ?
> 
> Yes, erase & insert and many other things are conspicuously missing from 
> D1 Phobos (not sure about D2 Phobos).  I like the collection of such 
> routines provided by the Cashew library in the cashew.utils.Array module.

OK, I will look it up. I did expect such functionlity to be part of the 
D run-time library or the language implementation itself.

> 
>> Furthermore in D 1.0 a char[], a dynamic array of characters, is the 
>> equivalent of the C++ std::string. In the C++ std::string class there 
>> is a rich set of functionality for manipulating the char elements in 
>> the string, for finding particular elements in the string, and for 
>> comparing the character elements in strings with other strings, but I 
>> see little of this in dynamic array functionality. What am I missing ?
> 
> Those functions are in std.string in Phobos.  And scattered all over the 
> place in Tango.

I see the Phobos std.string. It seems, at first glance, not nearly as 
rich an implementation as the C++ std::string functionality.

> 
>> I am guessing this must be provided in D libraries of functions ( 
>> Phobos ? Tango ? ) templated on the dynamic array type. 
> 
> Right.  Except for generic arrays, there's nothing in D1 Phobos.

This is surprising, but I will go with the link above you suggested.

> 
>> But, if so, this seems a poor way of providing dynamic array 
>> functionality as compared to built-in dynamic array functionality in 
>> order to provide the sort of functionality mentioned above, especially 
>> as D's dynamic arrays are part of the D language as opposed to a 
>> separate library like C++'s std::vector<T> and std::string.
> 
> Why?  What's wrong with providing such functionality as a library when a 
> library does the trick?

There is nothing instrinsically wrong with it when the library is 
generic enough, as in the C++ standard algorithms which access 
containers through the iterator concept.

> 
> Are you aware of the pseudo-member trick that works for arrays?  Example:
> 
>   T get_elem(T)(T[] array, size_t idx) {
>      return array[idx];
>   }
>   ...
>   float[] numbers = [1.f, 2,3];
>   float first = numbers.get_elem(0);
> 
> That works today in D1 and D2.  Any function that takes an array as a 
> first element can be treated as if it were a (non-virtual) member of the 
> array type.

Yes I remember seeing this in the documentation but did not appreciate 
its importance vis-a-vis an external dynamic array library.

> 
> So given that, I think there's really no reason for the bulk of D's 
> array functionality to not be in a library.

Agreed. Unfortunately I had missed where such a library exists, and 
assumed it must be part of the normal distribution.