Re: Two simple language questions

[mheaney@ni.net (Matthew Heaney)]

In article <68uq34$7tk@tomquartz.niestu.com>, chipr@niestu.com (Chip
Richards) wrote:

>I hope.
>
>First: It says in the Intro to Ada 9X, in Chapter 2, "General access types can
>also be used to program static ragged arrays as for example a table of
>messages of different lengths."  Now, I know this has been asked before, some
>time ago, but I cannot seem to locate the text of the exchange.  What I want
>to know is, exactly what is the syntax for doing this?  I've so far used
>allocators, i.e.:
>
>   strs:  StringArr :=
>   (
>       new string'("Line 1"),
>       new string'("Line 2"),
>       ...
>       new string'("Line the Last")
>   );
>
>Which works great, but isn't exactly the "static" ragged arrays mentioned in
>the intro.  What I want is something like "Line 1"'access, but of course that
>doesn't work, nor have any of the sixteen-umpty variations that I've tried.
>The RM just said that in X'access, X must be an aliased view of an object.
>Well, hmph.  Hep me, hep me, please.

I think an example is in John Barnes' book, but here's a solution:

declare
   Line_1 : aliased constant String := "this is line 1";

   Line_2 : aliased constant String := "this is the text of line 2";

   ...

   Line_Last : aliased constant String := "last";

   type String_Access_Constant is 
      access constant String;

   type String_Array is
      array (Positive range <>) of String_Access_Constant;

   The_Lines : constant String_Array :=
      (Line_1'Access, Line_2'Access, ..., Line_Last'Access);
begin
...
end;


>
>Second, a bit more of a philosophy question, I think.  I've had a couple of
>occasions where I've created Ada95 child packages, and in those packages, I've
>wanted to extend enumeration types defined by the parent.  As an example:
>
>   type Colors is ( Red, Green, Blue );
>
>And in the child, I'd like to be able to say
>
>   type More_Colors is new Colors with ( Yellow, Purple );
>
>Except, of course, that isn't Ada.  So, what's considered the best approach to
>this sort of thing?  Just re-list the constants of the parent type, and add
>the new constants into the list?  Seems a bit repetetive and error-prone to
>me, and I was just wondering if I'd missed someone proposing a more elegant
>solution.  Or am I really off the rails and missing something totally obvious?

No, you can't extend an enumeration type.  You can't extend the range of
any scalar type, not just enumeration types.  

You can get at the base range of the type by using T'Base.  However, for
enumeration types, the first named subtype is the base type (by
definition), so T'Base wouldn't buy you anything anyway.

If you want to "extend" a scalar type, then just used constant objects an
integer type, not an enumeration type:

type Color_Base is new Natural;

subtype Color is Color_Base range 0 .. 2;

Red : constant Color := 0;
Green : constant Color := 1;
Blue : constant Color := 2;

subtype Extended_Color is Color_Base range 0 .. 4;

Yellow : constant Extended_Color := 3;
Purple : constant Extended_Color := 4;

Declare objects and parameters of type Color_Base when you want to accept
any kind of color, extended or not.  Use the subtype when you want to
restrict the range (ie Color or Extended_Color).

BTW: as a point of Ada style, do NOT name scalar types as a plural noun. 
Do not say

   type Colors is...

say

   type Color is ...

The reason is that the object of the type holds only a single value, for example

   The_Color : Colors;  

doesn't make any sense.  The proper way is

   The_Color : Color;

Reserve plural names for objects of a composite type, for example

   type Color_Array is array (Positive range <>) of Color;

   Colors : Color_Array  := (...);

The plural name makes sense here, because Colors is an object that contains
multiple values.

Hope that helps,
Matt

--------------------------------------------------------------------
Matthew Heaney
Software Development Consultant
<mailto:matthew_heaney@acm.org>
(818) 985-1271