Re: Preventing private procedure visibility being made public through extension

["Randy Brukardt" <randy@rrsoftware.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:ofq943$14v4$1@gioia.aioe.org...
...
> ----------------------------------
> The actual problem you have is parallel types hierarchies. You want to 
> derive tied instances of Base_Type'Class and Base_Param'Class.
>
>    Base_Type ----- Base_Param
>       |              |
>    Derived_Type -- Derived_Param
>
> This requires
>
> 1. Full multiple dispatch
> 2. Dispatch constrained to certain combinations (parallel hierarchies)
>
> This is not supported in Ada (or in any other OO language I am aware of)

Right. Having investigated this, it seems impossible to support in any 
language that is intended to support LSP (which is the backbone of OOP). The 
basic problem is dispatching. In Ada terms, you have a call:

     Something (Classwide_Obj, Othertype_Obj);

where Classwide_Obj is of Root'Class. Now, the problem is that the other 
(usually untagged) parameter is of the wrong type for the routines that you 
dispatch to.

There are various ways you can fix this dynamically (for instance, as you 
noted, with multiple dispatch), but there is no way to have any static 
typing in these cases. But the entire point of doing a "co-derivation" is to 
get static typing, so you're doing a lot of work for very little gain.

Co-derivation probably could be made to work for untagged types (as they 
don't have dispatching to worry about), but it's unclear that enough benefit 
would arise.

Anyway, this is an agenda item for the ARG, but unless someone has an idea 
that hasn't been considered to date it isn't going anywhere.

                         Randy.