Re: Ada

[Hyman Rosen <hymie@prolifics.com>]

Richard D Riehle <laoXhai@ix.netcom.com> writes:
> Ada generics (templates)are always compiled before they are 
> "included" by the client.  This is a function of the Ada library
> model.  The instantiation is permitted only after the successful
> compilation of the generic unit.  This puts type checking a little
> closer to the origination of the generic.  
> 
> If I read the C++ literature correctly, C++ templates are expected
> to be "full expansion" units.  Ada permits a template to be instantiated
> in other forms to conserve memory. Some compilers support this.

You have not read the literature correctly, or you have not read the
correct literature :-) C++ templates can be (according to the standard,
but not yet in reality) separately compiled, and many errors within the
template can be caught before instantiation. You are correct in that it
is unlikely that a C++ will offer anything but the full-expansion style
of template instantiation.

> Ada has more formats for generic formal parameters.  This has its
> advantages and may sometimes have disadvantages.  The designer needs
> to learn more idioms of the language.  Once having learned those idioms,
> more options for template design are available.

C++ has essentially *no* format for its generic formals, which are
types, templates, or constants. I think that allows C++ to achieve
the same things with its templates that Ada can.

> Ada permits but does not require as much overloading of operators
> as one needs in a C++.  This is useful when one is creating templates
> for simple scalar and numeric types.  It does simplify the templates
> for those types.  Actually, in this case, the Ada model is somewhat
> an improvement over C++.  Of course, a C++ advocate may answer that
> the word "class" may be used for a built-in type, but this still falls
> short of the Ada model for range constraints and other rules of
> scalar types.

Well, C++ doesn't have range constraints and subtypes (which is
too bad), so it can hardly overload on them. But it does have
enumerations, and those are fully overloadable. But C++ doesn't
have attributes, so one can't write a generic wrap-around successor
function, for example, so there, I've found an example for you :-)

> Ada is more complicated when creating templates in which an entire
> package is a generic formal parameter.  C++ is very straightfoward
> in this regard.  The consequence is that this powerful feature of
> Ada is often ignored by component designers.  In time, as Ada 
> practitioners become more comfortable with its capabilities, we should
> see more use of it.  Meanwhile, C++ seems much easier when one needs
> one of more classes as generic formal parameters.

I hold that a C++ class is more-or-less equivalent to an Ada package,
so a generic formal package in Ada would simply correspond to a generic
formal class in C++.