Re: A bad counterintuitive behaviour of Ada about OO

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

On Sat, 9 Aug 2014 09:11:43 -0700 (PDT), Maciej Sobczak wrote:

> On Friday, August 8, 2014 3:22:56 PM UTC+2, Dmitry A. Kazakov wrote:
> 
>>>> I still do not understand the example.
>> 
>>> http://en.wikipedia.org/wiki/Covariant_return_type
>> 
>> type A is tagged null record;
>> function getFoo return A;
> 
> Wrong. getFoo should have a factory as a parameter (in the Wikipedia
> example this is hidden as "this" parameter). More complete example would
> be:
> 
>    package Products is
>       type A is tagged null record;
>       type B is new A with null record;
>    end Products;
>    
>    package Factories is
>       type A_Factory is tagged null record;
>       function Make (AF : in A_Factory) return Products.A;
> 
>       type B_Factory is tagged null record;
>       overriding function Make (BF : in B_Factory) return Products.B;
>    end Factories;
> 
> and GNAT says:
>
>    subprogram "Make" is not overriding
>    not type conformant with declaration at line XXX
>    return type does not match

The example does not make any sense. Since it would be impossible to
dispatch on Make without knowing the type of the outcome.
 
Factory pattern in Ada is this:

   type Factory is abstract tagged null record;
   function Make (F : not null access Factory) return A'Class;

Then you do:

   type A_Factory is new Factory with ...
   override function Make (F : not null access A_Factory) return A'Class;

   type B_Factory is new Factory with ...
   override function Make (F : not null access B_Factory) return A'Class;

And in case you do know the result type no factory object is ever needed,
because you just do:

   X : A;

> As Randy pointed out, this cannot work in Ada. It's not even a matter of "fixing" something.

It cannot work in any language, even if full MD were supported, which would
make your example possible. The pattern is just useless.

>> If you are in the hierarchy of the factory
>> type, there cannot be any covariance in an unrelated hierarchy.
> 
> This is *exactly* the definition of covariance, at least the one I know:

The notion of co- and contra-variance was given by Luca Cardelli. It is
related strictly to inheritance <=> a hierarchy. Outside a hierarchy it is
just meaningless.

>> No OOPL I know can handle this.
> 
> Have you heard about those niche and unpopular languages like C++ and Java? ;-)

Yes. They cannot handle this either.

Usual technique in C++ and Ada is to use template or generic to produce the
handle type. It is quite nasty and it loses the second hierarchy (of
handles). 

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