Re: Surprise in array concatenation

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"jimmaureenrogers@worldnet.att.net" <jimmaureenrogers@worldnet.att.net> writes:

>...Concatenating array A whose indices represent
> the null set with array B whose indices represent some non-null set
> should always result in an array whose indices are a non-null set.

Agreed.

> Moreover, the most efficient and logical merging of the two sets
> results in a set idenitcal to the indices of B.

I don't agree that's most logical, but I suppose that's somewhat a
matter of taste.

But the Ada rule is _certainly_ not the "most efficient"!

If all Strings start at 1, then we reduce the size of the array dope by
4 bytes.  If the average String length in your program is, say, 20
bytes, you're saving 4 bytes for every 24, or about 17% of the memory
use, which is substantial.  Saving memory generally speed up programs
due to cache effects.

It's really annoying to me that the compiler stores zillions of copies
of the number 1 in memory (one copy for each String object), just
because some oddball String _might_ start at other than 1.

Furthermore, bounds checking would be much faster, because there would
be no need to load the lower-bound from memory.  Memory loads are often
slow on modern machines.

Furthermore, consider the code generated for 'Length:  In Ada, it's
something like:

    if X'First <= X'Last then
        X'Last - X'First + 1
    else
        0
    end if;

If X'First were known to be always 1, it would be:

    X'Last

If X'First were known to be always 17, it would be:

    X'Last - 16

These latter are branch-free code sequences.  Branches are often slow on
modern machines.

- Bob