Re: Generics vs. O-O?

[optikos@verizon.net]

On Thursday, August 1, 2013 2:24:57 PM UTC-5, Dmitry A. Kazakov wrote:
> [... snip ...]
> 5. Considering run-time effects generics obviously have none because it is
> static polymorphism.
> [... snip ...]

Not so fast.  Your statement on your #5 is true for C++ templates, but not true for Ada generics.  The difference is that instantiations by different combinations of template-parameters of a C++ template result in a combinatorial explosion of the quantity of instances of that template's machine code & static data.

Conversely, Ada utilizes a single instance of machine code & static data for an Ada generic, regardless of the type parameters passed at compile-time.  This single instance of machine-code accommodates different type parameters by either branching (around different per-type-parameter treatment) or table look-up (of the size & structure of entities).  No such branching or table-lookup is present in the corresponding combinatorial explosion of C++ template instantiation.  This conflation by branching or table look-up in Ada is precisely why the combinatorial explosion does not occur in Ada generics, as it does in C++ templates.

Hence, Ada's branching and table-lookups will in fact incur some execution-time overhead when compared to analogous C++ templates and when compared to nongeneric equivalent functionality.  Conversely, when looking at code bloat, Ada's generics will incur some executable-size space overhead when compared to nongeneric equivalent functionality, but both the Ada generic and the nongeneric equivalent functionality will result in drastically smaller executables than a (naïvely-designed) C++ template that is instantiated with a vast quantity of combinations of parameters to that C++ template.  Hence, in C++, the best-practice is to manually design a C++ template whose nontemplated guts accomplishes the conflation that the Ada compiler performs for an Ada generic.  In C++ this often means that a type-safe C++ template thinly ricochets off to a nontemplate/nongeneric functionality that utilizes void* & corresponding sizeof to defeat all type-safety of objects or scalars.