Re: GCC 4.0 Ada.Containers Cursor danger.

["Robert I. Eachus" <rieachus@comcast.net>]

Mikhail Terekhov wrote:

> That means do it youself. So much for a "generic" library - if you need 
> some generic case - do it yourself.

No, what you are asking for is many more standard packages.  As Randy 
discribed in another part of this thread, the ARG worked to reduce the 
number of container variations that were part of the standard.  In doing 
this there are cases where one variant supports several different 
abstractions.  If you use the standard containers with any of those 
views, the packages are safe and efficient.  If you mix abstractions, 
you either have to choose a more expensive implementation, or risk 
erroneousness.

But it would be silly to provide half-a-dozen versions of some of the 
packages, one without Delete, one without cursors, one with a single 
cursor, and one with cursors that are always checked for validity, etc. 
  In practice if you need these abstractions materialized, it is less 
than an hour's work.  But most programmers don't even do that--they 
instantiate the package and document with a comment about how callers 
are expected to use the instance.

Yes, violations of those comments should be treated as programming 
errors.  It is one of the strengths of Ada that 1) you often can choose 
between compile time and run-time checking, and 2) you can use tools, 
such as SPARK, that pay attention to those comments, and validate them 
at compile time.

To summarize this long discussion, you say you know how to program badly 
in Ada.  I, and a lot of other people say, so do we, but we would rather 
not.  Years, ago I remember Robert Dewar, when talking about Spitbol I 
think, saying that there were two possible philosophies to use when 
creating programming languages:  Try to make it hard to do it wrong, or 
to try to make it easy to do things right.  In Ada we aim for both, but 
with a third caveat, which is that it should be possible to do anything. 
  Of course, to the maximum extent possible, we try to make doing 
something wrong and writing ugly code synonymous, and the same for 
elegant code and doing things right--from a software engineering 
perspective.  I think this is why you keep not getting it.  When someone 
says, this is a cleaner way to write that, and doesn't have the flaw you 
are worried about, they are really thinking that answers you.  But you 
would prefer not to be allowed to write erroneous programs in Ada. 
Sorry, see above. It is often not easy, but it can be done.  (At this 
point I should send you off to read G�del's Proof...)