Re: Ada.Strings.Bounded

[Robert A Duff <bobduff@shell01.TheWorld.com>]

Eric Hughes <eric.eh9@gmail.com> writes:

> On Apr 21, 7:02 pm, Adam Beneschan <a...@irvine.com> wrote:
>> The expected type is Z; therefore, in
>> example C, the only possible meaning for "-" is the function that
>> takes two arguments of type Z and returns Z.  That, in turn, applies
>> to "+". So it's 100% clear from the language rules what functions are
>> called by this expression.  The reason it doesn't raise
>> Constraint_Error is 4.9(33), as I mentioned earlier.
>
> OK.  But then what's the type of the subexpression "( Z0 + 1 )" within
> the static expression "( Z0 + 1 ) - 1"?  It can't be of type Z, since
> it's outside the bounds of type Z.  And the addition chosen can't be
> the same addition as the declared one, which returns Z, and that
> subexpression returns something that's not in Z.

Ah, I see what might be confusing you.  You need to understand the
difference between types and subtypes.  When you say:

    type Z is range ...;

you are declaring a type and a subtype (the "first subtype").  The name
Z refers to the firts subtype, and has the specified range.  There is no
way to refer to the type by name.  Strange, but true!  When I say "the
type Z", I really mean "the type whose first subtype is Z".
The RM sometimes uses the term "the type of subtype Z".

The operators of the type Z can return results outside the range of Z.
                     ^^^^^^
                     note sloppy/informal wording!

Consider:

    type T is range 1..10;
    A : T := Read_From_Keyboard;
    B : T := Read_From_Keyboard;
    C : T := (A - 1) + B;

Imagine Read_From_Keyboard reads a number between 1 and 10,
and suppose we happen to get A = 1, and B = 5.  C must equal
5, even though the intermediate result A-1 is out of range
for T.

The "base subtype", called T'Base, has an implementation-defined range,
which covers at least -10..10, but might well be something like
-2**31..2**31-1.  At run time, operators will get the right
answer if it's in the base range.  If it's outside the base
range, the compiler is ALLOWED to get the right answer, but
is also allowed to overflow.

>...  The addition used
> here has a different signature.
>
> It seems that the overload resolution rules don't apply when
> universal_integer is involved.  This seems a pretty obvious
> consequence of 4.9(33).

No, it's false, and is therefore obviously NOT a consequence of
4.9(33)!  ;-)

There are some special rules for univ_int (mainly, the implicit
conversions), but the rules apply.

- Bob