Re: Exceptions

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

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

> I don't buy the supposed need for two kinds of exceptions.

Maybe "kind" is the wrong term.  I think you want to be able to say,
"X can be raised by anything in this scope (including child packages)".
X might be Storage_Error, for example.  In fact, that should be the
default for Storage_Error -- there's no point in saying "This can
raise S_E" on every procedure in the program!

In any case, if you have checked exceptions, then you definitely need
unchecked ones.  That is, you need some way to say, "This cannot happen,
and I know that, and in this case I [think I] am smarter than the
compiler."

>... It seems to me to
> be an implicit recognition of the fact that the contracts aren't
> sufficiently useful for many kinds of subprograms. I think it would be
> better to fix the capability of the contracts (if that's possible) than to
> define a trivial way to avoid them.
>
> Once you have unchecked exceptions, the contract really doesn't tell you
> anything interesting (since it is the propagation of predefined exceptions
> that usually lead to bugs; only the rare case where the predefined exception
> is caught will tell you anything at all). Moreover, the temptation is
> overwhelming to use the unchecked kind everywhere, because it is less hassle
> and the checked kind doesn't buy that much anyway (it doesn't guarentee that
> all exceptions are handled, but only the rare few that are declared
> checked).

OK, I think you've convinced me, at least in the context of Ada,
and probably Java.

I think Constraint_Error needs to be a checked exception
-- otherwise, you miss a lot of bugs.
But pretty-much anything can raise C_E in Ada.

The solution must lie in having pre/post conditions and invariants,
and a fairly powerful way of checking them statically.  That's far
from the existing Ada.  Clearly, if:

    for I in A'Range loop
        ... A(I) ...

and:

    while X /= null loop
        ... X.all ...

require a handler for Constraint_Error, or a declaration that this
procedure can propagate it, then the feature is not terribly useful.

What I really want is something like SPARK, but with much
less restriction on features that can be used.

> It's much like the accessibility rules in Ada. They're immensely
> complicated, yet their original primary goal is completely ignored. I've
> never yet found an Ada program where I could use 'Access on an object; I
> don't even bother trying anymore. So why have all of that complication?
> (Yes, I know its useful for subprograms and tagged types, and we can't avoid
> it there.)

- Bob