Re: Inherited Methods and such

["Randy Brukardt" <randy@rrsoftware.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
news:19ie8rfpiitdx$.i2sz3r6uj66w.dlg@40tude.net...
> On Mon, 24 Sep 2007 20:59:53 -0500, Randy Brukardt wrote:
>
...
> > Ada has no choice. You agree that "magic" is needed to do the memory
> > allocation, layout, etc. for the underlying object. (To say otherwise
would
> > be to require all objects to be fixed in size.) But that is not
divisible
> > from the initialization of the value in Ada (and the values of the
> > components), because the memory allocation depends on the value of the
> > discriminants, and even the components that exist depends on those
values.
>
> It can be made divisible:
>
> For each type T we define a plain built-in record type T'Constraints such
> that it has all the constraints (discriminants, bounds, tags) of T. Prior
> allocation of T a user hook is called to return T'Constrants. It gets the
> parameters of the constructor. Then the memory is allocated. After that
the
> implementation type of T is constructed (the constraints are set, the
> components are constructed). Then we proceed to the construction of T.
Here
> the parent types are constructed first and finally a user hook equivalent
> to Initialize is called on T. For class-wide types there is an additional
> step where the class-wide user hook is called.

That's what I tried to do with Janus/Ada, and it doesn't work in all cases.
I don't have a specific example to give, but the problem comes from the
required order of evaluation; we were reading uninitialized values in
obscure cases. I couldn't find anyway around those requirements.

> > Note that this is very similar to the reasons that Ada cannot have
"real"
> > user-defined assignment; it's not possible to divide an assignment into
> > components managed separately.
>
> Same as above. Moreover it would be probably possible to make the old LHS
> visible in the hook computing the constraints.

No, you can't have visibility on both objects in a hook routine, because
there are cases where one side or the other does not exist. You have to
define three sets of hooks, which would greatly increase the chance of
errors and probably would be too complex for most to understand.

The problem doesn't exist if your language doesn't have disappearing
components, and I would be much more likely to try to approach the problem
from there. But that wouldn't be Ada.

                       Randy.