Re: Built-in types (was Re: How can I avoid Using a Semaphore?

[Robert Dewar <robert_dewar@my-deja.com>]

In article <94hmgo$o2k$1@nnrp1.deja.com>,
  mark_lundquist@my-deja.com wrote:
> If that's my only
> requirement, then I'm being explicit about it when I write
> "Integer", because that's what Integer is supposed to be --
> the "whatever integer".

In this very unlikely scenario, I would suggest writing

  type My_Int is new Integer;
  --  Use standard default (and presumably efficient) integer

so that if there are porting problems, or if you do need to
specify additional attributes, then it is easily done without
major rewriting.

> (Let's see, just for integer types, what can the programmer
> specify? There's base range, size, alignment, stream I/O
> attributes... anything else?)

Yes, there are other things, but the point is that we are
specifically talking here about a complaint that you can NOT
specify them for the standard type Integer. That's what this
thread is about.

It is curious logic to be in a position of saying

1. I want to use Integer when I don't want to specify any
   additional stuff.

2. It is annoying that for type Integer, I cannot specify
   additional stuff

that makes little sense to me!


> Well that's just it... it seems like if the programmer is
> sharp enough to specify all this stuff, then he also ought to
> be sharp enough to know when he means the "whatever" types
> and to use them when that's what he means.

Please give a VERY clear example of why it is good EVER to
use type Integer (other than when constrained by a library)?

Even if efficiency is a concern, the proper approach is to
write something like

   type Temp_Int is range min-required .. max-required;
   type My_Int is new Temp_Int'Base;

Now use My_Int. That's really MUCH better than using Integer
directly.


> There was a thread here last year, in which someone was
> lamenting that Ada's integer types were not as "portable" as
> Java's because the language doesn't nail standardize the
> sizes/ranges.

Well this of course makes no sense. In Java you only have the
standard types, so it is important to standardize them. In
serious Ada, you don't use these standard types anyway, so
the fact that they are not defined is not relevant to serious
programs.

Of course at this stage, it would in practice be fine to define
type Integer as being always 32 bits, precisely because serious
code is not going to use this much anyway.

Well to be honest (as they say in the AARM), we can't do that
*because* of the involvement of Integer with Standard.String.


Sent via Deja.com
http://www.deja.com/