Re: Inherited Methods and such

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

"Maciej Sobczak" <see.my.homepage@gmail.com> wrote in message
news:1190843408.713838.128690@g4g2000hsf.googlegroups.com...
...
> > And why "constructor functions" do not solve it?
>
> Constructor functions in Ada are functions that return new objects
> (most useful for limited types since Ada 2005) can have parameters,
> but they still don't acknowledge the "progressive" nature of the whole
> process. This means that no matter whether we use Initialize or
> constructor functions, the final type of the object is established at
> the very beginning and is kept during the whole construction process.
> If this process involves some activities on various levels of the type
> inheritance chain, the ugly effects like the one from my example can
> result, because primitive operations can be called bypassing the
> intended order of component construction.

Well, if you insist on doing bad things in your constructor (calling
dispatching routines), you will obviously get problems. So what? I'm not
sure what your argument is.

It's surely not possible for a language to catch all possible errors (simply
because not everything can be proven), so there are always going to be
things that as a programmer we're going to have to avoid. That's part of the
reason why programming is not something everyone can do.

There is no possible mechanism in Ada that could prevent calling of
dispatching routines in bad places. Changing tags cause a number of bizarre
anomalies (and also would probably destroy the existing Ada implementations,
all of which assume that tags never change). Additional "hooks" would help
nothing, because you still could do the bad thing (calling dispatching
routines inside the hook).

So it seems this is a discussion of limited relevance to Ada. Following any
one of a number of good Ada practices would have avoided the problem: Don't
redispatch in a constructor (or Initialize) routine; don't leave scalar
components/objects uninitialized at declaration; never assume a scalar
object is initialized. Maybe this isn't ideal, but it is what we've got.

                            Randy.