Re: Language lawyer question: task activation

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

On Fri, 20 Feb 2009 23:19:04 +0100, Georg Bauhaus wrote:

> Dmitry A. Kazakov wrote:
> 
>> It neither computes nor assigns, because construction/initialization is not
>> assignment. It is a different thing. The LHS object does not exist prior
>> construction, but does prior assignment.
>> 
>>> The word "in-place" is not in Ada, only "build-in-place".
>>>
>>> Then, a procedure returns, too. Consequently, a
>>> function returning yields a value.
>> 
>> What does it return? Note that it does return an object, that were illegal
>> because the result is limited.
> 
> I suppose it is just a wording question: When
> a function returns, there is a yield.
> 
> When a procedure P(Object: out T) returns, there
> is a yield (in Object).

No, it is not so. The actual of Object out T is constructed *prior* to call
to P. In contrast the "actual" of F return T is not constructed (when T is
limited). This is exactly the thing that worries me. Because it makes out T
and return T different, while they are evidently same.

> Assume the following language experiment:
> If T is limited, we might write
> 
>    X: constant T;
> 
> begin  -- not Ada
> 
>    T'Initialize(X, Celsius => 27.3);
> 
> or some such, with the understanding that the object
> named X will be provided by declaration, but will not
> be initialized. Instead, it will have its initial
> value when T'Initialize has returned.

Unfortunately it is impossible to have pure "out". Again, because that is
inconsistent in the same way the return statement is. You cannot pass an
non-existing object to a subprogram, be it an out parameter or a result.
The object simply does not exist, there is nothing to pass. In fact it is a
kind of raw memory being passed. Worse than that it is rather an idea of
raw memory, in the case of function result.

> Initialization is very much part of object construction in
> other languages, sometimes resource management is normally
> left to the implementation, too, like in Java, or Eiffel.

It must be clearly understood and *spelt* in the language, that
initialization is not an assignment. Initialization cannot be implemented
by any operation defined on the type of the object being initialized.
Period.

If you want to do it *consistently* (typed), you have to decompose
initialization into operations of *other* types. But it remains still
impossible without some magic, called "constructor." The best thing you can
do is to allow some hooks in the constructor to be implemented by
user-defined operations.

A constructor of T as a whole is not an operation of T in any properly
typed system.

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