Re: Copying rows in a two dimensional array.

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

tmoran@acm.org writes:

>> In Ada, if you do "P(X(5..10));" procedure P can see that the
>> lower bound is 5.  That's a break in the abstraction -- P shouldn't
>> know or care where the string came from.
>     For many, but not all, P.

Can you give an example where P should know that its String
parameter came from a slice, and should know the lower bound
of that slice?  I can't think of any off the top of my head
-- it just seems like a fundamentally broken abstraction if
you care about the lower bound of a string.

Just to be clear: I'm talking about Strings here, and other
array types that have a natural lower bound (usually 1,
sometimes 0).  I'm not necessarily talking about all
array types -- the discriminated arrays feature I am
imagining would allow the programmer to choose whether
to fix the lower bound at a particular value.  Or the upper
bound, or both, or neither.

>> Actually, slices are one of the least useful features of Ada.
>> I wouldn't mind (much) if they didn't exist in the first place.
>    Wow, I beg to strongly differ.

OK, I guess I shouldn't have said "least useful".  I should have
said that it's easy enough to work around the lack of this
feature.  In my experience, almost all slices are of
type String.  And almost all are R-values.  So a function:

    function Slice (S: String; First: Positive; Last: Natural) return String;

would do the trick, at some small efficiency cost.  (Note that we
tolerate this interface in the case of unbounded strings.)

Think about it this way:  Name some features of Ada that you
would rather do without than slices.  I can think of a few,
but not many.  It would be much more painful to do without,
say, case statements than slices.

Or think about it this way:  Name some features that Ada does
not have that you'd be willing to trade slices for.  For example,
I'd love to be able to fix the lower bound of an array type, and I'd
happily do without slices for that.  ;-)

And if you want a really useful/powerful slice facility, look to
Fortran!

- Bob