Re: List container: Insert and Delete

[Ted Dennison<dennison@telepath.com>]

In article <9sok8i$142am0$2@ID-25716.news.dfncis.de>, Nick Roberts says...
>
>"Ted Dennison" <dennison@telepath.com> wrote in message
>news:Z0JH7.21323$xS6.32782@www.newsranger.com...
>> Right now we are working on a defintion for *unbounded* lists, on the
>> theory that this is the most basic need. Bounded is for special cases. If you
>>
>However, it would be nice to have an identical, interoperable, interface to
>both kinds of list, no?

I've been thinking over that question myself, and right now I'm not sure what
the answer is. I can see two basic approaches here.

Approach one is, as you say, try to create 2 List packages with identical
interfaces, as near as possible. One would be "Bounded" and the other would be
"Unbounded". I'll call this the Stringslib choice, as this approach is inspired
by the approach taken by Ada.Strings.*. The other choice is to have separate
interfaces for bounded and unbounded Lists (in this case, probably "Vectors" and
"Lists" respectively) that are each designed around providing facilites that are
available and efficient for the implementation in question. I'll call that the
STL choice, as that's the way the STL did things.

I see two main advantages to the Stringslib approach. First, it is consistent
with the approach taken for the current Ada.Strings.* packages. That would
hopefully make it a more natural fit into the existing Ada library. Secondly,
there is only one interface to learn, so all the user has to worry about is the
trade-off between flexibility and dynamic memory use, and the relative speed of
typical operations in an array vs. heap environment.

However, the STL approach is attractive to me for several reasons. One is that
the design approach deals with abstractions rather than implementations. To me
that is generally a more sound approach. Another issue is that if we make some
kind of "Least Common Denominator" interface between the two implementations,
one of them is going to get short-changed. For instance, an array-based "Vector"
list could allow direct elment access via discrete type indices, just like an
array does. Why take that away, just because heap Lists can't do it?

But for the most part, I think we can delay resolving this partiular issue until
we are ready to deal with Bounded lists.

---
T.E.D.    homepage   - http://www.telepath.com/dennison/Ted/TED.html

No trees were killed in the sending of this message. 
However a large number of electrons were terribly inconvenienced.