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

[Georg Bauhaus <rm.tsoh.plus-bug.bauhaus@maps.futureapps.de>]

Dmitry A. Kazakov wrote:

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

Yes.

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

I meant to say that the derivation should not work in the
following sense. T being (<>)ed, abstract, and limited means,
clients are supposed to not even try to create objects of this
type. The choice is deliberate. There is no way to construct
objects of type T. There is no way to construct objects that
somehow involve T objects, e.g. objects of types derived from
T publicly. The (<>)'s message is that T's objects are handled
in the private part.  None of our business.

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

The constructor is private because T(<>) has private
constratints only. IOW, clients cannot construct
an object either of class T (C++) or of type T(<>) (Ada).

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

When S is derived from some public T without a (<>),
I can name T in S'(T with ...) when T is just abstract.
This illustrates that (<>) prevents (meaningful) public derivation.
An abstract T is just a means to allow concrete types derived
from T. (<>)ing T says, "Keep your hands off!".