Re: Problem using Ada.Text_IO.Modular_IO

[Adam Beneschan <adam@irvine.com>]

On Jul 10, 12:25 am, a...@anon.org (anon) wrote:
> It is easy to use and is tested and verified to work! To name one to
> two reasons!

Those don't seem like much of a reason.  Declaring your own type as
"mod 2**64" seems pretty darn easy.  And what exactly do you mean by
Unsigned_64 is "tested"?  Unsigned_64 is simply declared as "mod
2**64" (this is specified by the language); so are you saying that
operations on Unsigned_64 have been tested and have found to work
right, but if you declare your own "mod 2**64" you have to do your own
testing to make sure that operations on it work right?  I'm having
trouble interpreting your comment in a way that makes any sense.

Of course, it really doesn't matter which one you use (except,
perhaps, to help prevent incorrect type conversions).  The only
differences have to do with readability, pedagogy, and helping make
your programs self-documenting.  But ever since Ada was designed, the
position of the Ada community has been that it's better to avoid using
the standard numeric types provided by Ada (Integer, Float) and define
your own that explicitly include the numeric range you need.  You seem
to be going in the opposite direction, by recommending that this user
use a standard type provided by the language rather than defining his
own (although the standard type you recommend is certainly better
defined than Integer or Float).

Another issue is that an implementation doesn't have to provide
Interfaces.Unsigned_64.  It should be present on any target processor
whose addressable unit is an 8-bit byte or a 16-, 32-, or 64-bit
word.  But I've seen processors in the past that use 6-bit characters
or 36-bit words, and in those cases, using Unsigned_64 instead of "mod
2**64" will turn a portable program into a nonportable one.  I'll
grant that such processors are rare these days.

                                  -- Adam