Re: Ada generics

["markww" <markww@gmail.com>]

Hyman Rosen wrote:
> 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.

Thanks for your detailed responses, I appreciate it,

Mark