Re: Question for the folks who designed Ada95

[Keith Thompson <kst@cts.com>]

Robert A Duff <bobduff@world.std.com> writes:
[...]
> We didn't think it was necessary -- you can always multiply by 2 or
> whatever.  Optimizing that to a shift instruction is trivial, and if you
> care about efficiency, surely you should be using an optimizing compiler
> that is *at least* that smart.  (After all, I want that optimization for
> signed integers, too!)

That's fine if the size of the shift is a constant, but as someone
else has pointed out, it's more difficult if it's a variable.  I
suppose a compiler could optimize
    
    X := X * 2**N;

to a shift instruction, but I'd hate to have to depend on it.

> It's not clear what shifting should mean if the modulus is not a power
> of 2.  Robert has stated many times that that should never have been
> allowed, and I tend to agree.

Do you mean that shifting should not be allowed for such types, or
that the types themselves should not be allowed?  Either way, I also
tend to agree.  Non-power-of-two modular types remind me of
enumeration representation clauses -- something that was added for the
sake of completeness, but that's more trouble to define and implement
than it's really worth.

If non-power-of-two modular types are really worth having in the
language, it might have been nice to make them a distinct class of
type, like decimal fixed-point vs. ordinary fixed-point.  That would
allow providing shifts as attributes without running into generic
contract model problems.  I think.

Disclaimer: I've been mostly out of touch with Ada for the last couple
of years, so I've probably made some mistakes.

-- 
Keith Thompson (The_Other_Keith) kst@cts.com  <http://www.ghoti.net/~kst>
San Diego Supercomputer Center  <http://www.sdsc.edu>                 <*>
Techno-geek.  Mouse bigger than phone.  Bites heads off virtual chickens.