Re: A simple ADA puzzle (I haven't the answer)

["Frank J. Lhota" <NOSPAM.lhota.adarose@verizon.net>]

"Randy Brukardt" <randy@rrsoftware.com> wrote in message
news:KZedneo665VD3EbdRVn-uA@megapath.net...
> I really see no downside to requiring this support - customers want it and
> try to use it all the time; it wouldn't have a performance impact on types
> that already work; and the restriction No_Implicit_Heap_Allocation would
be
> used if you really had to avoid the overhead. But I'm in the minority on
> this one.

As a recent convert, I can tell you how I became convinced of this point of
view. When it comes to implementing variant records, there are two ends of a
spectrum where the correct course of action is easily determined:

1) If the size of the record does not vary much, e.g. if the type
discriminants allow the length of a character array to vary from 1 to 20
characters, then you might as well eschew the overhead of heap allocation
and simply create the object "in place".

2) If the size of the record varies widely depending on the discriminants,
so that a variable of this type can store values that vary from 10 bytes to
10,000,000 bytes in length, then either the programmer or the compiler
should implement these objects using the heap. We can complain about the
overhead, but there is no other way.

But what about the cases between these two extremes? Assume that we are
writing code that is to be ported to multiple platforms. Assume further that
the variations in size of an object of our record type are large enough so
that on platforms with tight memory constraints (say embedded DOS) would
require heap allocation, but small enough that static allocation is an
option on other platforms. How do we write something that works and is
optimal for all platforms? Ideally, shouldn't the programmer write what is
desired, and let the compiler decide the most appropriate way to implement
it for the given platform?

When this argument occurred to me, it was one of those "Eureka!" moments.
Although it is too late to get this into Ada 0x, perhaps we can get this
changed for Ada 1x.