Re: To Initialise or not

[Ken Garlington <garlingtonke@lmtas.lmco.com>]

One correction to an earlier statement I made (which actually has very little
to do with explicit initialization to null, but anyway...)

I said that you should be able to use 'Size to ensure that an invalid
representation of a scalar exists. AI95-00051 correctly points out that
there will be at least two cases where this shouldn't happen:

1. With an aliased object. (However, you should be able to use 'Size on
the type of that object, at least in some cases).

2. With an object that already takes up all the size available for that
architecture (e.g., an integer from System.Min_Int to System.Max_Int).

(I don't exactly buy the fixed/floating point restriction, BTW, and I sent
in a comment on that).

So, what do you do then? Well, it seems to me that you could have, in the
body of the abstraction, a check to see if an invalid value is possible.
At least, you can check integers and enumeration values against System.Max_Int;
I'm guessing there's a more general case that would handle modular types,
and maybe the other cases,too. Anyway, assuming you could devise such a test,
you could have that test done during the elaboration of the type abstraction
and cause Program_Error to be raised. Then, you could have a second generic
that would be used in those cases, which would have the type wrapped in a record
that also contained a boolean called "Unset". The code in the ADT could initialize
this to True, and then set it to False any time a Set operation was called.
That's a little slow, but you would only need it for those types that can't have
their own built-in out-of-range value, which should be a fairly small subset of
the types in an average program.

-- 
LMTAS - "Our Brand Means Quality"