Re: Why constructing functions is a mess [was Language lawyer question: task activation

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

On Sat, 28 Feb 2009 13:20:51 +0100, Georg Bauhaus wrote:

> Dmitry A. Kazakov wrote:
> 
>> Topic: large system design, information hiding:
>> 
>>       type T (<>) is abstract tagged limited private;
>>    private
>>       type T (...constraints...) is abstract tagged limited record
>>          ...
>>       end record;
>> 
>> In order to be used in
>> 
>>    type S is new T with ...;
>>    function Create (....) return S;
> 
> How/Why should this derivation be possible?

Because it is so in Ada (the discriminants are inherited).

The idea of <> introduced in Ada 95 was to be able to hide the
discriminants. The idea of Pickwickian function was in part to overcome Ada
design bug that the discriminants can be hidden but not abstracted.

Note that if T weren't abstract, a Pickwickian function would work:

   type T (<>) is tagged limited private;
   function Create (...parameters...) return T;
private
   type T (...constraints...) is tagged limited record ..

Observe, that this abstracts the discriminants of T, which in the public
part are represented by the arguments of Create. Now the arguments of
Create are kind of "public discriminants." The private discriminants are of
nobody's interest.

Another Pickwickian construct is limited aggregate in which you can use a
Pickwickian call to the Pickwickian function Create and this incredible
combination gives us an ability to implement Create of S with whatever
parameters you need.

Nevertheless it miserably fails:

1. It does not work with abstract types.

2. It exposes Create of T as a primitive operation of. That means that S
have to provide Create with *exactly* same arguments as ones of T! This is
a catastrophe. There is absolutely no reason for S to implement this
Create. It would have its own with parameters of its own. (Constructors are
NOT inherited)

3. You still cannot publicly extend T if you have to add some new
discriminants. Discriminants still are not properly abstracted.

(This cannot be saved, it is just wrong.)

>> In order to be used in
>> 
>>    type S is new T with ...;
>>    function Create (....) return S;

> (Deriving publicly
> from an abstract limited type with unknown discriminants--to me,
> the <> signals the intent of the author of T, namely that T
> should be considered none of our business?)

Exactly. This is why a user of public T must be able to construct T knowing
nothing about the discriminants of T.

>> Remember? Constructor is not function. It never will. See the problem?
> 
> Assuming C++ has constructors, will your arguments apply
> in the following examples (just trying to understand):
> 
> class T
> {
> public:
>   virtual void op() = 0;
> private:
>   T(char constraint) : c(constraint) {}
>   char c;
> };

No, the constructor in the example must be public. Probably you refer to
the trick when <> is used to prevent uninitialized objects. But T is
already abstract. You cannot create it in any way.

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