Re: Half Constrained Array Types and Slices

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

"Jeffrey R. Carter" <spam@spam.com> writes:

> Robert A Duff wrote:
> > I'm not so sure about that.  I'm inclined to say slices always slide to
> > the lower bound.  The idea that X(3..5) should have lower bound 3 seems
> > to make sense at first, until you think about passing that slice as a
> > parameter.  The called procedure should not care that it's a slice at
> > all -- much less the particular bounds used to create it.  The Ada rule
> > violates abstraction.  Same issue for function returns.
> 
> OK. So you're saying a slice (Lo .. Hi) of an unconstrained array type
> would slide to Index'First .. Index'First + Hi - Lo?

Yes.

> > Yes, I agree that's a problem.  Various possible solutions come to
> > mind.  Probably the simplest is to outlaw slices of constrained arrays.
> > After all, what is the sense in saying "all arrays of type T go from
> > 1 to 5", and then turn around and create values of type T with bounds
> > 3..4?  Even in Ada as is, there is very little use for this feature.
> > You can do:
> >     type Bits is array(Int range 0..31) of Boolean;
> >     function Rotate(X: Bits) return Boolean Bits is
> >     begin
> >         return X(31) & X(0..30);
> >     end Rotate;
> > But that's not worth much language complexity.  If you want that,
> > declare an unconstrained (doubly unconstrained?) array, along with
> > constrained subtype(s).
> 
> That was the rule in Ada 83, IIRC. It apparently bit enough people that
> it was changed in Ada 95.

I don't know of any change between 83 and 95, here.
But I could be forgetting something; please remind me.

Anyway, my suggestion was to forbid (at compile time) any slices that
might cause confusion in the mind of the programmer, or run-time
errors.  I think I'd be happy with a language that allows slices only
when the lower-bound is fixed.

I'd also be happy to eliminate slices as l-values.  They cause a lot of
implementation difficulty for not much benefit.  Or else go the whole
hog, and allow X(5..10) := "xx", which does not work in Ada, because
that would require changing the length of the whole thing.

> > I can talk about more and more exotic ideas, depending on how far away
> > from Ada you're willing to contemplate.  ;-)  For example, I'd like to
> > be able to do:
> >     type T(D1: ...; D2: ...) is ...
> >     subtype S is T(D1 => 17); -- Illegal in Ada to partially constrain!
> > Or maybe the syntax should be "T(D1 => 17, D2 => <>)".
> 
> In that case, this would be how you'd deal with slices of
> half-constrained arrays if you wanted to keep the bounds; the base type
> would be unconstrained and the first-named subtype would be partially
> constrained.

Yes, but this is all very not-Ada in several ways.
There are probably some semantic anomalies I have not considered.

- Bob