Signed integer to modular type conversion

[adam@irvine.com (Adam Beneschan)]

Supposing Standard.Integer is a 32-bit signed integer type.  I have a
modular type

    type ModType is mod 2**32;

    X : Integer;
    Y : ModType;

I'd like to set Y := X mod 2**32 (which should essentially just treat
X as an unsigned integer without changing the data).  However, I can't
figure out a good way to do this in Ada.  Using "mod" won't work,
because there is no integer type that can be used as a parameter to
"mod" that will take 2**32 as a parameter (I'm assuming that 32 bits
is the largest integer type supported by the compiler).  A type
conversion won't work, because it will raise Constraint_Error if X is
negative.  I could do something like

    if X < 0 then
	Y := ModType (X + ModType'Modulus/2) + ModType'Modulus/2;
    else
	Y := ModType (X);
    end if;

but this seems awfully silly for something that really should be just
a no-op on the machine.

Am I missing something, or is Unchecked_Conversion (or Pragma
Suppress) really the only reasonable way to accomplish this?  Unless
I've forgotten something, it seems quite odd that Ada provides modular
types but does not provide a solution for this (other than going
through the "back door" by using Unchecked_Conversion or Suppress).

If there is no solution, I'd like to propose adding an attribute so
that you could write something like

    Y := ModType'Mod (X);

This attribute would be defined for modular types and would return
X/ModType'Modulus.  I know, "Mod" is a bad name for the attribute.

My apologies if this has been discussed at length before.

				-- Adam