Re: Mutable parameter of a function (long ago was: Re: What evil would happen?)

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

On Mon, 5 Jan 2004 21:01:28 -0600, "Randy Brukardt"
<randy@rrsoftware.com> wrote:

>In parameters and constants just provide a constant view of an object. But
>nearly every object has a variable view as well -- you just can't explicitly
>name it. Initialization and finalization are always done on a variable view
>of the object - even if it is declared as a constant.

Yes. A constant is just something like:

<Invisible> : X := <initial>;
Visible : constant X renames <Invisible>;

This is consistent and fine, because then Initialize/Finalize are
called on <Invisible>. The only problem is when the variable view
becomes available through a constant one. Using Rosen trick, for
instance. I'd like to close such gaps where possible, but it is too
late of course. At least we could reduce unintentional trickery by
allowing return for procedures.

>That will be more obvious in Ada 200Y, because of the ability to initialize
>limited objects. A constant of a limited type might contain a task;
>certainly that task will run and modify its local objects without any regard
>to whether it is declared in a constant or variable. The task will have a
>variable view of its containing object, even if the program as a whole only
>has a constant view of the object.

It is no problem to me, because it would be a designer's choice
whether the task should have an access to the enclosing object (Rosen
trick again).

I share the point that "constant/in" should be only a view. I.e. for
by-reference types it does not propagate down to all components. That
would be either impossible or inconsistent (considering components of
access types). For by-value objects one could imagine that kind of
implementation (a user-defined, of course), though that is irrelevant
as long as such types have no user-defined
constructor/destructor/assignement.

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