Re: Help - Constructors - ASAP.

[Matthew Heaney <matthew_heaney@acm.org>]

Mats Weber <Mats.Weber@elca-matrix.ch> writes:

> > Now a client can just refer to P.Bounded_String.
> 
> This works as long as the package that implements the type exports only one
> type and only primitive operations of that one type, but that is far from the
> most common case, at least in my code. Take for instance Sequential_IO:
> 
> package P is
> 
>    package Implementation is new Sequential_IO(Whatever);
> 
>    type File_Type is new Implementation.File_Type;
>    type File_Mode is ???; -- no clean way of doing this
> 
> end P;

You bring up a very good point.  (This is same "feature" you highlighted
in your PhD.)  One rule of thumb is that, if possible, don't declare
anything in a generic except the "main" abstract data type.  Declare
supplementary types in another package - perhaps a non-generic root
package.  In your example, type File_Type (and Count) could have gone in
package Ada.  (Of course we can't really do that for Seq_IO, for obvious
reasons.  But consider doing this for packages you write.)
 
> Another problem, which I think is even worse, is when some operations of a
> type are generics (e.g. iterators), then these will not be derived and you
> will have to get them from the package that declares them.

You can rename generic operations.

> Not to mention the fact that the rules on type derivation, primitive
> operations, etc. are one of the obscure areas of the Ada language. Not to me,
> I know how they work, but I have had to teach quite a few people to overtake
> code that uses some (really not much) type derivation, and nobody seems to
> find it natural. E.g. when you see
> 
>    X : P.T;
> 
> begin
>    P.Op(X);
> 
> you expect to find a declaration for Op in P, right ?

Indeed, this is true.  Many Ada programmers don't have a clue about how
inheritence for non-tagged types works, and certainly don't take
advantage of it.  (And those who do use it, just confuse the others).

In another post a few weeks back, I observed that if people really
wanted to simplify Ada 83, then type derivation would have been a good
candidate for removal.  I think that this is one of those things that
only Jean wanted, and he used his veto power over the rest of the DRs to
keep it in the language.