explicit instantiation of mpl typelists

Hi,

I'd like to meta-program explicit instantiations of my classes based
on the contents of mpl typelists (such as boost::mpl::vector
instances), so that i can control what to instantiate from one header
file.

So far, I wrote the following:

// BEGIN CODE
#include <boost/mpl/fold.hpp>
#include <boost/mpl/transform_view.hpp>

template <template <typename> class D>
struct instantiator
{
    template <typename V>
    struct apply {
        typedef D<V> type;
        // template D<V>; // CAN EXPLICIT INSTANTIATION BE
METAPROGRAMMED ???
    };
};

template <template <typename> class D, typename TL>
struct typelist_instantiator : boost::mpl::transform_view <TL ,
instantiator<D> > {};

struct empty_base {};

struct make_pair
{
    template <typename Head, typename Tail>
    struct apply {
        typedef std::pair<Head, Tail> type;
    };
};

template<typename TypeList>
struct tuple0: boost::mpl::fold<TypeList, empty_base, make_pair>::type
{};

// instantiate default-constructor of D<V> for each V in TypeList
template <template <typename> class D, typename TypeList>
void instantiate_typelist() { tuple0<typelist_instantiator<D,
TypeList> > x; }

// definition of template <typename T> DataArray omitted;
// definition of typelists::value_types omitted;

// explicit instantiation of instantiate_typelist
template void instantiate_typelist<DataArray,
typelists::value_types>();

// END CODE

As you can see, explicit instantiation of the instantiate_typelist
function almost does the trick, except that it requires that the
instantiated class template has a default constructor, and I rely on a
undocumented compiler feature that instantiating a constructor of a
template class gives a result similar to explicit template
instantiation. With explicit instantiation I would have a better
guarantee that static member functions (such as Create functions) and
static data members (such as MetaClass objects that register such
Create functions) are instantiated too.

Furthermore, I'd like to dispatch to the instance of an operator class
template that relates to the dynamic type of an object (such as done
with the double dispatch pattern that requires the visitor to have a
virtual function for each of the possible types of the inviter).

So, to summarize my question to you: How can one put a mpl typelists
to work?

Maarten.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]