Re: I am not understanding user defined exceptions

[Robert A Duff <bobduff@TheWorld.com>]

"Randy Brukardt" <randy@rrsoftware.com> writes:

> The GNAT approach causes a very significant maintenance hazard: if you 
> depend on the static properties of a predicate, a seemingly innocous change 
> can break a lot of code. (And that code may not even be yours, if the 
> predicate is in a specification of a shared library. Imagine someone 
> changing a predicate in the specifications of GDKAda that changes it from 
> static to dynamic; a lot of other people's code would break ...

I don't buy it (as you may remember, because I said so in an ARG
meeting).  The reason is that all these horrible things you mention
can happen when you change a static predicate to a different static
predicate.  E.g.:

    subtype S is Integer with Static_Predicate => S >= 0;

If you change it to:

    subtype S is Integer with Static_Predicate => S >= 1;

client code is just as likely to break as if you changed it
to a dynamic predicate.  So what?  Any time you change the
visible part of a widely used library unit, you have to be
careful about breaking clients.

Note that the first S above is exactly the same as:

    subtype S is Integer range 0 .. Integer'Last;

And we don't bother to mark that as a static range.
You could change it to "0 .. Dynamic_Value", and break
clients.

>...and they'd have 
> no understanding of why (or any hope of fixing it).

Now that's REALLY overstating the case.  Anybody who can read Ada code
can understand why (and hope to fix it).

>... By declaring your intent 
> as static or dynamic, clients can properly use the predicate subtype and you 
> as the maintainer can't break their expectations without at least realizing 
> that there is a potential problem.

The above argument proves that to be wrong -- the maintainer CAN
break clients DESPITE the fact that the predicate is marked
Static_.

> This is especially true as many expressions that *seem* simple aren't 
> allowed as static predicates (simple math operators aren't allowed, for 
> instance). After all, a static predicate is a (bizarre) way to describe a 
> set constraint, whereas a dynamic predicate is an implicitly inserted 
> assertion. Quite different semantically.

In the same sense that a static constant is quite different from a
dynamic one.  For example you can say "when X =>" in a case
statement if X is static.  And if somebody changes X to a different
static value, or to a dynamic value, the case statement will
become illegal.

- Bob