Re: Weird behavior with modular type

[Adam Beneschan <adam@irvine.com>]

On Feb 7, 9:24 am, Yannick Duchêne (Hibou57)
<yannick_duch...@yahoo.fr> wrote:
> Hi all,
>
> I expect the test to be shortened enough.
>
> The following compiles and run without an error:
>
>     with Ada.Text_IO;
>     procedure Bug is
>
>        type Modular_Type is mod 256;
>        subtype Index_Type is Natural range 1 .. 3;
>
>        E : Modular_Type := 255;
>        I : Index_Type := 3;
>        B : Boolean;
>
>     begin
>        B := E < 10 ** I;
>        Ada.Text_IO.Put_Line (Boolean'Image (B));
>     end Bug;
>
> It prints "FALSE"
>
> Now, the following, with added "Natural'Pos (...)", did not even compile:
>
>     with Ada.Text_IO;
>     procedure Bug is
>
>        type Modular_Type is mod 256;
>        subtype Index_Type is Natural range 1 .. 3;
>
>        E : Modular_Type := 255;
>        I : Index_Type := 3;
>        B : Boolean;
>
>     begin
>        B := E < Natural'Pos (10 ** I);
>        Ada.Text_IO.Put_Line (Boolean'Image (B));
>     end Bug;
>
> That's counter intuitive. I would expect the first to behave as the
> second, with either a failure to compile or range error at run-time.
>
> Someone remember a pointer to the most relevant part in the RM? I may be a
> bit tired, could not find it.
>
> Seems in the first case, the left-side of "E < 10 ** I" has a modulo
> applied, or else, I see no way to explain the result, "FALSE". But why
> would this modulo be applied with a subtype of Natural and not with an
> Universal_Integer?
>
> I don't like it (and must be idiot in some way, don't you think?).

In the first example, 10 ** I is a modular operation; the left
argument of ** is a modular type (whose value is 10), and the right
argument is of type Natural.  (The right argument of the predefined
"**" is always of type Integer [sometimes subtype Natural], unlike
most other predefined binary operations which have the same type for
the left and right arguments.  Maybe that's what's confusing you.)
Anyway, since 10 ** I is an operation on a modular type, it wraps
around.  In the second example, 10 ** I is an operation on Natural,
because it's the expected type when you have Natural'Pos; here, the
left argument is an Integer value of type 10.  So Natural'Pos (10 **
I) has value 1024, and it's an error to convert it to a modular type
when it's out of range.

                     -- Adam