Re: conversion

["Robert I. Eachus" <rieachus@attbi.com>]

Dmitry A. Kazakov wrote:

> If you mean that unversal integer is something like String, then you
> are probably right. But the difference is that we cannot declare
> objects of universal integer. On contrary, for strings we can, but
> surprisingly that type is called "Unbounded_String" and even more
> surprising is that it is unrelated to String.

No! No! No!  You are very confused.  First of all, what do you think the 
type of Foo is in:

   Foo: constant := 123456789012;

(Actually in Ada 95 it is _root_integer_ while the literal 123456789012 
is of type _universal_integer_, but that is a detail. (_root_integer_ 
includes all other integer types, including _universal_integer_.)

The Integer type that corresponds most closely to String, is Integer, 
and they are both declared in Standard.

> It is clear (isn't it) that all different string types have same
> semantics and differ only in how they implement that semantics. So
> they should be related.

Yes, so the three different implementations are all clustered under 
Ada.Strings: Ada.Strings.Fixed, Ada.Strings.Bounded, and 
Ada.Strings.Unbounded.

 >                             That length of a String value cannot be
 > changed is just a value constraint which by no means changes string
 > semantics.

No. String values are never constrained, String objects are always 
constrained, often by their initial values.  If I have a function that 
may return a different length string every time it is called, and that 
length is unpredictable in advance?  That is not a problem, it is a 
common idiom:

     while not Done loop
       declare
         Buffer: String := Get_Line;
       begin
         -- process Buffer...
       end;
     end loop;

There is no static/dynamic dichotomy here, nor is there a 
bounded/unbounded distinction, or even constrained/unconstrained. 
Buffer is always constrained to be the same length as the String 
returned by the most recent call to Get_Line.  (Unfortunately that 
function is not Ada.Text_IO.Get_Line, but I hope we will fix that next 
time around.)

> So instead of looking for explanations which I doubt would convince
> anybody, one could simply admit that, yes, String and Unbounded_String
> should be better siblings, but to do it consistently would require too
> many changes Ada's ADT model.

Ada.Strings.Fixed, Ada.Strings.Bounded, and Ada.Strings.Unbounded are 
the siblings.  It may bother you that Ada.Strings.Fixed reuses String, 
and Ada.Strings.Bounded is a generic package you have to instantiate, 
but those are not the issues you are describing here.

> For example, what would happen if
> 
>    type Name is new Unbounded_String;
> 
> Should it produce a new String type? Surely. How should it be named?
> Who knows.

It would be named Name, unless I am missing something, just as:

type New_String is new String;

Creates a new string type named New_String.  Or if you prefer:

type New_String is array(Positive range <>) of Character;
pragma Pack(String);

Do that in Ada and you will find that you get a type with literals like 
"foo"...  String is not a priviledged type in Ada.  You can even create 
a new character type--Character is similarly not special.  For example 
you could create a Cyrillic character type which used ISO 8859/5 
Latin/Cyrillic with the upper and lower pages reversed.  Or whatever.  A 
character type is an enumeration type with character literals.  A string 
type is any array of any character type.
-- 

                                                        Robert I. Eachus

�In an ally, considerations of house, clan, planet, race are 
insignificant beside two prime questions, which are: 1. Can he shoot? 2. 
Will he aim at your enemy?� -- from the Laiden novels by Sharon Lee and 
Steve Miller.