Re: Sharing generic bodies across instantiations.

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"Randy Brukardt" <randy@rrsoftware.com> writes:

> You need to read about the Ada contract model for generics. (Off-hand, I 
> can't think of a good reference, however.)

The AARM talks about it.  Not exactly an "easy read".  ;-)

I think maybe the Ada 83 Rationale talks about it.
There were some holes in the contract model in Ada 83,
which were patched in Ada 95.

>... Part of the Ada contract model is 
> that there cannot be an error caused by the actual parameters of an instance 
> in an instance body. Tucker Taft liked to describe the model as 
> "assume-the-best" in the specification and "assume-the-worst" in the generic 
> body. Thus there are a lot of things that are illegal in a generic body in 
> Ada simply because they *could* be illegal in some instance of that generic. 
> C++ has no such counterpart (indeed, I recall reading that Stoustrup [sp] 
> explicitly eliminated it from C++ templates because it was too complex).
>
> In addition, binding of names in the generic body always takes place at the 
> point of the compilation of that body. That means that most operations at 
> determined at that point, facilitating sharing. (This also causes the 
> sometimes bug of "reemergence" in generics, where a hidden predefined 
> operator is used instead of the user-defined one for the actual type.) C++ 
> uses a more macro approach to template expansion.

It makes C++ templates more powerful than Ada generics.  The downside is
that if you're writing a reusable and widely-reused library, it's
difficult to know (in C++) whether some change might break clients.
The other downside is that error messages are typically
incomprehensible; in Ada you don't get normally get errors in instance
bodies, so they can't be incomprehensible.  ;-)

- Bob