"Yannick Duchêne (Hibou57)" wrote in message news:op.wwbw2ho9ule2fv@cardamome... ... >However, tagged types may be excluded (ex. if there are proof >requirements) or not available (ex. the runtime in use does not support >it). That's a bit a pity to not be able to use something like >`Ada.Finalization` for applications not using tagged types. I even believe >`Ada.Finalization` is harder to avoid than tagged types >(`Ada.Finalization` looks more fundamental to me), especially that it >comes with added safety (as much as strong typing and ability to return >unconstrained types are). My understanding is that safety-critical people are scared of anything that has implicit behavior (like Finalization or dispatching). As such, there isn't much value to having them separated as the people that can't use the one probably can't use the other as well. And outside of such restricted environments, there's not value to avoiding tagged types. It should be noted that finalization on all types had some semantic problems (such as finalization on by-copy parameter passing - which would make it hard to call a procedure Finalize without infinite regress) which were solved by limiting the capability to tagged types. Whether there was a better solution is hard to say at this distance -- keep in mind that the prevailing feeling among the reviewers was that the general finalization you are talking about was too complex for the Ada 95 definition. A small group of die-hards (which I somehow got the reputation of being the leader of), convinced Tucker to try again with a simpler model -- which turned into the tagged model we have today. So my point is the that the question is not whether general finalization would have been better than tagged-type only finalization. It was whether tagged-type only finalization was better than nothing, because there was no chance of the general finalization being in Ada 95. Finalization is far too important for us to have waited another 12 years to get it, so what we've got is the best that we could have gotten. Randy. -- "Syntactic sugar causes cancer of the semi-colons." [1] "Structured Programming supports the law of the excluded muddle." [1] [1]: Epigrams on Programming - Alan J. - P. Yale University