Re: Preventing private procedure visibility being made public through extension

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

On 2017-05-20 19:33, Jere wrote:

> package Derived is
>     
>     type Derived_Param is new Base.Base_Param with null record;
>     
>     type Derived_Type is new Base.Base_Type with private;
>     
>     procedure Something
>        (Obj : in out Derived_Type;
>         Value : Derived_Param'Class)
>     is null;
>     
>     type More_Derived_Type is new Derived_Type with private;
>     
> private
>     
>     type Derived_Type is new Base.Base_Type with null record;
>     
>     overriding
>     procedure Something
>        (Obj : in out Derived_Type;
>         Value : Base.Base_Param'Class)
>     is null;

This is not private regardless where it appears. When you derive from 
Base_Type that automatically declares Something for Derived_Type. You 
may override its body but that is all you can do. When you declare 
another Something for Derived_Param'Class that overloads the already 
inherited Something and here you are.

> Is there a way for me to prevent extending types from making
> the procedure public again?

It is public. That was the decision made in the package Base. The 
package Derived has no say on that.

----------------------------------
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)

A typical workaround is replacing multiple dispatch (pos.1) with a 
cascaded dispatch. I.e. you keep Something class-wide in the second 
parameter. Then you override it as you did. In the body you select the 
parameter type in any desired way (second dispatch).

The drawback is obviously loss of static type checks (pos.2):

    procedure Something
              (  Obj   : in out Derived_Type;
                 Value : Base_Param'Class
              )  is
    begin
       if not Value in Derived_Param then -- or a more relaxed
                                          -- Derived_Param'Class
          raise Constraint_Error with "Value type error";
       end if;
       declare
          Checked_Value : Derived_Param renames Derived_Param (Value);
       begin
          ... -- Go on

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