Re: A bad counterintuitive behaviour of Ada about OO

[Maciej Sobczak <see.my.homepage@gmail.com>]

W dniu sobota, 9 sierpnia 2014 18:48:33 UTC+2 użytkownik Dmitry A. Kazakov napisał:

> The example does not make any sense. Since it would be impossible to
> dispatch on Make without knowing the type of the outcome.

The example does not make any sense, because it is not supported by Ada. It does make perfect sense in those languages that support it.

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

Wrong. Or rather half-way right. I also want to do this:

   Y : B := Make (B_F);

In other words, if I know that I have a Cat_Shelter, then I want to get a real Cat from it, not some unspecified Animal (nor Animal'Class). So I want this to be possible:

   X : A := Make (A_F);  -- base obj from base factory
   Y : B := Make (B_F);  -- derived obj from derived fry
   Z_1 : A'Class := Make (A_F);  -- class-wide from base fry
   Z_2 : A'Class := Make (B_F);  -- class-wide from derived fry

All of them have real-life interpretations with any of the example use-cases that I have listed below. I can do all of them in C++.

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

Useless?

- A Singer can sing a Song, but a Blues_Singer can sing a Blues_Song.
- I can get an Animal from an Animal_Shelter, but I can get a Cat from the Cat_Shelter (this is the Wikipedia example).
- A Coffee_Machine can make a Coffee, but a Special_Coffee_Machine can make a Special_Coffee.
- A Programmer can write a Program, but an Ada_Programmer can write an Ada_Program.
- (etc. billion of other such examples)

As I have already stated, every creational design patter can benefit from covariance on return type. I would not call this "useless".

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

You must have failed to read the Wikipedia articles that I have pointed.

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

You must have failed to read the Wikipedia articles that I have pointed.

> Usual technique in C++ and Ada is to use template or generic to produce the
> handle type.

Unrelated. Please focus on the examples that I have provided.

-- 
Maciej Sobczak * http://www.msobczak.com * http://www.inspirel.com