Re: Array Of Constant Strings?

[Jeffrey Carter <jrcarter@acm.org>]

Dennis Lee Bieber wrote:
>         Ah, but perusal of the reference manual appendix A indicates that 
> bounded string is a private type, which means no direct assignment to 
> it.

This is not right. Assignment is defined for private types; assignment 
is not defined for limited types.

Maybe that's not what was meant, but it's what it looks like to me.

>>I can throw in explicit conversion functions:
>>
>>   function To_Name_String(Source: String;
>>                           Drop:   Truncation := Right)
>>                           return Name_String renames
>>     Name_Package.To_Bounded_String;
>>
>>and then make the Name_List this way:
>>
>>   Name_List : constant array(1..26) of Name_String :=
>>       (To_Name_String("Anthony"),
>>        To_Name_String("Barbara"),
>>        To_Name_String("Claudia"),
>>        ... and so on.

Name_Package.To_Bounded_String returns Name_Package.Bounded_String, not 
Name_String, which is a different type. This renaming is not accepted by 
GNAT 3.15p (assuming appropriate visibility of Truncation and Right).

In any event, the derived type Name_String inherits the function 
To_Bounded_String which is directly visible, so no renaming is necessary.

Some people like to use a unary operator such as "+" for common 
conversions. There was a proposal for the Ada 95 revision to allow a 
special unary operator with no predefined meaning for this purpose. It 
wasn't accepted, and that turns out to be good, since the character for 
the operator symbol that would have been used has now been changed to 
the Euro symbol. Personally I think "\" would be a good operator for 
this simply to give C people fits :)

So, if you rename To_Bounded_String to "+", you could write

Name_List : constant array (1 .. 26) of Name_String :=
    (+"Anthony",
     +"Barbara",
     +"Claudia",
     ... and so on.

I don't like this, though. One of Ada's explicit design goals is to 
emphasize ease of reading over ease of writing, and "To_Bounded_String" 
is clearer than "+" to the reader. This is the opposite of C's 
philosophy, in which ease of writing is everything and ease of reading 
is unimportant.

Ada.Strings.Bounded.Generic_Bounded_Length is intended to be mentioned 
in a use clause; it's written in such a way that things are still easy 
to understand in that case. So I would recommend:

package Package_Name_Is_An_Elephant is new Generic_Bounded_Length (7);
use Package_Name_Is_An_Elephant;

Name_List : constant array (1 .. 26) of Bounded_String :=
    (To_Bounded_String ("Anthony"), ...);

If all the strings are always the same length, then using fixed length 
strings is even simpler. However, I would tend to be suspicious of such 
a requirement; things like that are almost always changed later.

> with Ada.Strings.Fixed; use Ada.Strings.Fixed;
> procedure aoc is
>         type Name_String is new String(1..7);
> 
>         Name_List : constant array(1..5) of Name_String :=
>            ("Anthony", 
>                 "Barbara", 
>                 "Claudia", 
>                 "Deborah", 
>                 "Elliott" );
> begin
>         Null;
> end aoc;

Why is Ada.Strings.Fixed mentioned here? It's not used anywhere.

-- 
Jeff Carter
"Spam! Spam! Spam! Spam! Spam! Spam! Spam! Spam!"
Monty Python's Flying Circus