Re: seperate keyword and seperate compilation with Gnat?

[dewar@cs.nyu.edu (Robert Dewar)]

"> your statement as normative text, then it is redundant, and redundancy,
> while useful in tutorial material is the enemy of precise definition.

Well here we just plain disagree.  In fact, this statement is
positively wog-boggling.

says Jon

he completely misses my point. His proposed additional statement adds
nothing to the RM. It is not some complex theorem that needs proving,
it is completely obvious. As I said earlier, it would perhaps stand
as a note, although for my taste even as a note it is useless baggage.

I am using redundant here not in some technical sense, but in an informal
sense. Adding the statement to the RM that you don't have to have subunits
around when you compile the parent unit is just unnceessary.

Actually it is worse than unnecessary, it is confusing. It implies that
perhaps other things that are not mentioned as having to be around might
have to be around. For example should we have a note saying that bodies
of transitively withed units do not have to be around? I would say yes,
if you add Jon's peculiar note.

This really seems an odd argument. Everyone knows and has always known
(who is familiar with Ada) that of course you don't have to have subunits
around to compile the parent unit -- it's the whole POINT of subunits.

For some reason, Jon got confused by what GNAT was doing, and was for a 
moment insecure on this point (as his wandering through the RM showed).
Well this can happen to all of us, and is occasionally useful in
deciding to put a note in, but I can certainly say that if this had
been submitted to the ARG, it would just have been dismiseed as an 
obvious confirmation.

There are many places one could worry about the RM being tricky to follow.
This is not one of them!

Jon, if all you are proposing is adding your one sentence, I think that
would be actively harmful. When you say unnecessary things, you raise
worries about parallel cases.

For example, suppose someone starts worrying whether it is valid to 
compute a + b as (4 * a + b - 3 * a), which could raise intermediate
overflow.

The answer is of course that of course this is invalid (to raise the
intermediate overflow because of using such a scheme).

According to Jon's thinking, as far as I can understand it, if someone
was confused on this point, he would suggest adding a statement like

"computation of the addition operator cannot involve unneceessary
intermediate overflow"

or somesuch

but that would be actively harmful, because it would worry people that
perhaps such overflow WAS allowed in other cases, e.g. subtraction.

That's why I storngly dislike the idea of a specific rule, or even a note,
that says that this particular kind of unit is not needed. We have a
general concept of semantic dependency, which is well defined in the RM,
and covers ALL such cases in a nice uniform way -- why single one out
just because someone got confused by what one implementation did?