Re: Anybody in US using ADA ? One silly idea..

[Hyman Rosen <hyrosen@mail.com>]

Richard Riehle wrote:
> Here is a generic in Ada, which while not identical to the C++ model,
> does permit combining specialization with genericity and which has
> turned out to be quite useful for certain kinds of problems.

This looks like something we would write in C++ like this:

template <class Item>
struct Starting_Type : public Item
{
	void Make();
};

I agree - there are plenty or circumstances where this is useful
and powerful.

C++ template specialization is different though; it doesn't
(necessarily) involve tagged types at all. Here's a simple
example:

// General case
template<int N>
struct Factorial { enum { Value = N * Factorial<N - 1>::Value } };

// Specialization for 0
template<>
struct Factorial<0> { enum { Value = 1 } };

// Use it, as a compile-time constant expression
int array[Factorial<5>::Value];

When you ask for Factorial<0>, the compiler uses the special case
you provided, otherwise it uses the general case. Notice that the
bodies of the specialization is completely different from the one
in the general case. (They both define a Value enumerator, but in
general, they could have been completely unrelated.)

The same thing works for type parameters:

// General case
template <typename T>
struct RemovePointers { typedef T type; };

// Specialize for pointers
template <typename T>
struct RemovePointers <T *> { typedef RemovePointers<T>::type type; };

RemovePointers<double *****>::type its_a_double = 17.29;

When you ask for RemovePointers<SomeType>, the compiler matches
SomeType against the specializatons. If it finds that one of them
is a better match than the generic type (using rules defined by
the language), it uses that one.