Re: Ada generics

["Hyman Rosen" <hyman.rosen@gmail.com>]

markww wrote:
> I'm trying to compare generics in Ada vs C++ templates

There are fundamental differences between the two languages in how
generics work that relate back to how types themselves work.

In C++, a type is a completely static thing. You can read a type
declaration in the code and know everything there is to know about it.
In Ada, types are much more dynamic - they can include information
known only at run type, such as array sizes and discriminant values. (I
don't know Ada, so pardon me if I'm wrong in the Ada details.)
Accordingly, C++ types don't have a lifetime as such, existing for the
life of the program, but Ada types have the same lifetime as other
objects in the scope in which they are declared. Among other things,
this means that C++ types can be assigned unique names at compile time
while Ada types cannot.

Now, imagine you have a generic which wants to take a type parameter.

In C++, because types are fixed and uniquely named, the generic itself
can be instantiated at compile time. The compiler has all the
information it needs. Furthermore, the instantiated generic can also be
uniquely named. This becomes the paradigm of generic instantiation in
C++ - to do it all in the compiler. Thus, generics may take non-type
parameters as well, but they must all be constant (or refer to the
address of a static object). As an additional consequence, C++ is able
to identify instantiations with each other based on identity of the
template parameters so that, for example, the type std::vector<int> in
one file is exactly the same type as std::vector<int> in a second file.
It also makes automatic instantiation of function templates easier,
since again the full set of needed instantiations is known at compile
time, and instantiations with the same set of parameters are identified
with each other. For example, in a function template containing a
static variable, there is one such variable generated for each
different set of instantiation parameters.

In Ada things are different. Because types have lifetimes and contain
runtime information, generic instantiations must also. Furthermore, in
Ada even functions and procedures have lifetimes, because they nest and
have access to outer variables. Now it is not possible to know at
compile time how many generics need to be instantiated, and you cannot
identify a generic instantiation simply by looking at the generic and
its parameters. Each instantiation is separate, and that makes
automatic instantiation of generic functions problematic, because it
may be difficult to know when to do a new instantiation and when to
reuse an existing one. On the other hand, since you are already so
dynamic, there doesn't need to be any restriction on non-type
parameters, and so in Ada you can instantiate generics on
locally-scoped functions and objects.

Because(?) Ada requires explicit instantiations, it has no notion of
generic specializations. This means that in Ada you cannot do
metaprogramming the way you can in C++. In Ada a generic has one and
only one implementation, whereas in C++ a template can be specialized
for different sets of template parameters. On the other hand, Ada is
much more friendly to generic sharing, that is, having a single or a
few compiled functions that can act at runtime as particular
instantiated functions.