Re: another way to shoot yourself in the foot?

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

Dmitry A. Kazakov wrote:

> The enclosing object does not expect
> its components to prematurely finalize themselves. It is just a bad design
> turned upside down:

It seems like everyone wishes to force dynamic context
information to be expressible as static type features,
together with implicit callback operations from
Controlled'Class.

Why not use plain old scopes when establishing context
for objects? Or generic elaboration.

Is anything wrong with having all of lifetime, startup and
cleanup of objects controlled by a combination of: nesting,
making calls, handling exceptions, and scoping?
Would Finalize be superior when calls from within it will
have to refer to all kinds of other data anyway,
even indirectly?

The Controlled subprograms are linked to a single type.
From what I know about Aspect Oriented Programming, it shows
that building modules around a single type does not always
yield the right abstraction: When the thing is seen from a
different angle, the type should have a different interface.
From yet another viewpoint, the type's operations should
cooperate differently.  In still another perspective
some abstraction is not represented by this type alone.
Instead, it would be represented by some combination of
this type and another type.

And now automatic operations like Initialize and Finalize,
hooked on a single type (and possibly discriminants---does
GNAT like at last :-) are supposed to be the solution of
all data management?