Re: Private discrete type as index

["James S. Rogers" <jimmaureenrogers@worldnet.att.net>]

"AG" <ang@xtra.co.nz> wrote in message
news:RKJT9.21144$F63.395685@news.xtra.co.nz...
> Hi all,
>
> Guess I have a question that I'm a bit puzzled about.
> Consider the boiled-down code snippet:
>
> package test is
>   type x is limited private;
>   type test is array(x) of boolean;
> private
>     type x is new boolean;
> end test;
>
> Trying to compile that fails on GNAT
> with "Discrete type required" error.
> Can't blame it, of course, since it's
> correct according to LRM. But...
>
> the obvious intention was to provide
> a set of "+/-" operations etc on the
> limited type (which are not trivial)
> and prevent the out-of-package clients
> from messing with the index.
>
> Since the compiler obviously knows
> the implementation details, why not?
>
> Of course, it can be implemented as
> an iterator, but what's wrong with
> the example as written? After all,
> the client modules can't use that
> index other than through the type
> and operation provided by the
> package. Compiler/linker sure knows
> what the type is. So, why not?

At the point of declaration of the array type the index type
is not specified as a discrete type. The array type is not private.
The nature of the index type must be visible within the scope of
the declaration of the array type.

You can try an approach like the following, which does compile:

package Type_Definition is
   type Index_Type is limited private;
private
   type Index_Type is new Integer range 1..10;
end Type_Definition;

package Type_Definition.Collection is
   type Collection is limited private;
private
   type Collection is array(Index_Type) of Boolean;
end Type_Definition.Collection;

Of course, each package would also have primitive subprograms
to manipulate the values.

Note in the example above, the array is defined in the private
part of the child package, which has visibility to the private part
of the parent package.

Jim Rogers