Re: conversion

[Dmitry A. Kazakov <mailbox@dmitry-kazakov.de>]

On Thu, 03 Jul 2003 07:03:43 GMT, "Robert I. Eachus"
<rieachus@attbi.com> wrote:

>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_.)

This is what I meant. You can consider string literals as being of
some unversal string type. Then you can have some parent string type
for all string types. Call it root string if you want. The hierarchy
might look like:

root string
   universal string = Unbounded_String
      String
      Bounded_String
      user-defined strings with literals
   user-defined strings with no literals

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

It does not. Because Integer is constrained.

>> 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.

This does not help. Types have to be related, order of packages is
rather a cosmetic thing.

> >                             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;

You missed the point. String as a concept has a semantics which allows
*any* values. That String as a type implementing  the concept has
values constrained in some special way, does not change that
semantics.

>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.)

Yes.

>> 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.

The problem is. Should String and Unbounded_String be siblings
(descendants of same base), or better, as many would rightfully
expect, String be *both* a subtype and a supertype of
Unbounded_String, then we will have a lot of problems to solve.
Because ADT in Ada is presently unable to deal with that.

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de