Re: Operation can be dispatching in only one type

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Thu, 19 Nov 2009 17:54:40 -0600, Randy Brukardt wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
> news:1iipp3bn16fe2.yqa1gz1ru17a$.dlg@40tude.net...
>> On Wed, 18 Nov 2009 18:27:42 -0600, Randy Brukardt wrote:
>>
>>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
>>> news:1wtsriaxu0s4s$.ikwnnz5teukp$.dlg@40tude.net...
>>> ...
>>>>> OK, I don't understand this.  First, I don't understand what about
>>>>> accessibility checks was a disaster;
>>>>
>>>> Because they are the major contributor to hours spent on debugging
>>>> unhandled exceptions.
>>>
>>> That seems odd to me. I rather *like* getting unhandled exceptions, because
>>> it is almost always easy to see what the problem is from the exception name
>>> and the traceback.
>>
>> Only theoretically. Practically, the existing handlers of "legal"
>> exceptions get perplexed, the stack gets wound up causing a cascade of
>> exceptions in Finalize's.
> 
> That might be true in general, but definitely not in this case: a handler 
> for Program_Error is *always* wrong (unless it is a global handler for *any* 
> exception), as Program_Error always represents a program bug. So I don't see 
> how "existing" handlers can be confused.

exception
   when Error : others =>
      some cleanup  -- This usually becomes a problem
      raise;

> It is necessary to treat all Adjust and Finalize routines like task bodies 
> in that they need a "when others" handler -- otherwise the exceptions are 
> sucked up and you get completely lost. Our programming standard requires 
> such handlers (generally, they output Exception_Information to the logging 
> facility - and almost every significant Ada system needs some sort of 
> logging facility).

Yes, but this does not help. Upon exception propagation (Constraint_Error),
you get some objects finalized. This in turn causes a snowball of
exceptions in finalized objects, because no design is robust to hold any
error at any place. In the end you have a huge log of meaningless messages,
which only complicate debugging. Sometimes I which Ada had "halt at once"
statement which would stop all tasks and hold any I/O.

But of course the proper solution would be contracted exceptions.

>> The difference is that for string bound there is a way to do it safe and
>> for 'Access there is none (and I also agree with Robert's response.)
> 
> Well, Ada 2012 (or whatever it will be called) should help that out by 
> giving you a way to compare accessibilites (via memberships). So at least 
> you will be able to make checks to avoid the problem. Better than nothing, 
> but still not ideal. The better way to avoid the problem is to never, ever 
> use anonymous access types. (Named access types have checks that are always 
> made at compile-time for most compilers -- but not Janus/Ada, because of 
> generic sharing.)

The problem is not bound to only anonymous types. It also appears when you
convert access types. The source type (or both) might be a formal generic
parameter, so you cannot statically ensure that a "local" pointer is
converted no a "less local" one. Pool specific pointers need to be
converted though one target object is derived from another. Here everything
is broken: generic contract, meaningless conversion, meaningless check,
meaningless exception.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de