Re: Exceptions

["Peter C. Chapin" <pchapin@sover.net>]

Randy Brukardt wrote:

> The ARG has discussed "exception contracts" a couple of times, but there
> didn't seem that there was enough interest...

These sort of issues have also been discussed at length in the C++
community, mostly in the context of why C++'s exception specifications
were a mistake. In those discussions I've heard many reasonable people
also express the opinion that Java's statically enforced exception
specifications were a bad idea.

The problem often quoted is that there are cases where an exception
looks like it could happen, but for reasons the compiler doesn't know
can't actually happen. As a simple example consider the code fragment

if Has_Acceptable_Value(X) then
  P1(X);
  P2(X);
  P3(X):
end if;

Suppose P1 raises an exception if X is negative. Depending on what
Has_Acceptable_Value does, it is quite possible that can't happen in the
code above. If you specify exception contracts the way Java did, then
the programmer in the above case ends up having to handle an exception
that won't happen or claim to propagate and exception that won't get
propagated. Either option is undesirable.

While one could argue that it is safest to assume the exception might
happen anyway (since Has_Acceptable_Value might change or be incorrect),
forcing empty handlers all over the place to cover such possibilities
doesn't seem right either. In fact, such handlers would probably eat the
unexpected exceptions and actually prevent buggy from being discovered
and fixed. In this respect exception contracts might actually reduce
reliability rather than promote it.

C++ checks exception specifications at run time, but then it's hard to
know what to do when a check fails. C++ throws a different exception in
that case, but that doesn't really solve anything as far as I can see.
The C++ community seems to have concluded that being able to declare a
function as throwing no exceptions is potentially useful, but that there
is little point in trying to go beyond that.

It seems like Ada got this right by not attempting to provide language
based exception contracts. Adding such contracts to Ada might well be
taking the language in the wrong direction.

Peter