Re: Converting access values

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

Nick Roberts <nick.roberts@acm.org> writes:

> Mark Lorenzen <mark.lorenzen@ofir.dk> wrote:
> 
> > As I said in another posting, I am going for a design like this:
> > 
> > type Buffer_Slice is
> >    record
> >      Data  : Buffer_Ptr;
> >      First : Ada.Streams.Stream_element_Offset;
> >      Last  : Ada.Streams.Stream_element_Offset;
> >    end record;
> > ...
> > It solves the problem, but exposes a bit more information to the clients
> > than necessary. It is very easy for a client to address a slice outside
> > the bounds:
> > ...

To avoid that exposure, you can make the Buffer_Slice type private,
and provide the appropriate operations as subprograms.
The Buffer_Slices package can easily enforce the desired bounds checking.
Unfortunately, you then lose all the nice notations for dealing
with arrays -- you have to say "Set_Nth_Element(X, I, Blah)"
instead of "X(I) := Blah", or whatever.

> Since you put it that way, I see your point. I suppose it is an area where
> Ada fails to provide a level of abstraction that perhaps it should. It's
> almost as if we want a new kind of access type, the 'slice access' type,
> that can point to a slice of an array, e.g.:
> 
>    type Buffer_Slice is access range Stream_Element_Array;
> 
> objects of which, when dereferenced, can be used anywhere a
> Stream_Element_Array object can, and have the same attributes (First and
> Last and so on).

I don't agree with that approach.  The underlying problem here is that
private types cannot be made to mimic the predefined syntax.  I can
think of dozens of abstractions that are like arrays, where one would
like to use array-like syntax.  The Buffer_Slice thing that Mark
Lorenzen wants is just one example.  Sure, you could add that to the
language directly, but then you haven't solved the general problem.
The "right" solution, in my opinion, is to extend the "user-defined
operators" idea to allow user-defined array-indexing, literals,
aggregates, &c.

A similar issue: Ada does not support arbitrary-range integers.
Of course you can define a package to do it.  And you can define "+",
"*", &c to do the right thing.  But then you lose constrained subtypes,
case statements, integer literals, &c., all of which work fine on the
*predefined* integers.

- Bob