Re: Wanted: Ada STL. Reward: Ada's Future

[Hyman Rosen <hymie@prolifics.com>]

Stephen Leake <Stephen.Leake@gsfc.nasa.gov> writes:
> Ok, that's what I thought. The STL style of expressing ranges as [i,j)
> is an consequence of the implementation, not a requirement of the
> design.

That is not at all what I said. It's a consequence of the desire to
allow arrays to function naturally as STL containers. That makes it
part of the design.

> I don't see why allowing pointers as iterators is a good idea in the
> first place. How do you efficiently maintain the head and tail
> pointers, or other list-wide state, for a doubly linked list when you
> insert from a plain pointer? Apparently you don't!

What in the world are you talking about? Every STL container has an
associated iterator type (two actually, one for constant containers).
STL algorithms operate on iterators, or ranges expressed as a pair of
iterators. The iterator for an array is a plain pointer to array
element, but the iterator into a more complicated container such as a
linked list is certainly not!

> So for an Ada "STL", we can either use [i,j) to be somewhat compatible
> with C++ STL, or we can use [i .. j] to be more Ada-like. I'm not
> clear what the best choice would be, but I lean towards being
> Ada-like. I'd rather woo good Ada programers than ex-C++ programers :).

OK. Just keep in mind that STL allows something like this:

#include <algorithm>
#include <vector>
#include <iterator>
#include <iostream>
using namespace std;
int main()
{
	vector<int> a;

	copy(istream_iterator<int>(cin), istream_iterator<int>(),
	     back_insert_iterator(a));
}

Here, istream_iterator<int>() represents a one-past-the-end iterator of
an input stream. The other iterator, istream_iterator<int>(cin), becomes
equal to the end one when end-of-file is encountered. The copy algorithm
is simply

template <typename In, typename Out>
Out copy(In from, In to, Out where)
{
	while (from != to)
		*where++ = *from++;
	return where;
}

> Again, insisting that a plain pointer can be an iterator is too
> restricting.

As I said, a plain pointer is an iterator of an array. Iterators to
more complicated structures are not plain pointers to element types.