C++ meta Programming to create a new typelist with remove_const applied to each element

Question

Hi Could anyone give me a sample program to "Create an ApplyRemoveConst template that constructs a new typelist with remove_const applied to each element"

For example:

typedef TYPELIST_3(A, const B, B) TL;
typedef ApplyRemoveConst<TL>::Result TL2;
// TL2 is the same as TYPELIST_3(A, B, B)


//Typelist Definition:

template<class T, class U>
struct Typelist
{
    typedef T Head;
    typedef U Tail;
    // Lets us a print a typelist
    inline static ostream &print(ostream &os) {
        return printInternal(os, "[");
    }
    inline static ostream &printInternal(ostream &os, string delimiter) {
        os << delimiter << typeid(Head).name();
        return Tail::printInternal(os, ", ");
    }
private:
    Typelist(); // Cannot create!
};

#define TYPELIST_1(T1)  Typelist<T1, NullType>
#define TYPELIST_2(T1, T2) Typelist<T1, TYPELIST_1(T2)>
#define TYPELIST_3(T1, T2, T3) Typelist<T1, TYPELIST_2(T2, T3)>

// Null type definition 

class NullType{
public:
    // NullType ends a typelist (just like NULL ends a C string)
    inline static ostream &printInternal(ostream &os, string delimiter) {
        return os << "]";
    }
};

Answer 1

I think what you want is something like this:

template <typename, template <typename> class>
struct transform;

template <template <typename> class Func>
struct transform<NullType, Func>
{
    typedef NullType type; // nothing to do
};

template <typename T, typename U, template <typename> class Func>
struct transform<Typelist<T, U>, Func>
{
    typedef typename Func<T>::type Head; // apply to head
    typedef typename transform<U, Func>::type Tail; // tail is transformed tail

    typedef Typelist<Head, Tail> type; // put together
};

This applies something recursively. It makes a new list, by applying to the head, then taking everything else as the tail, applied. That in turn applies the head, and so on, until a NullType is reached in which we just get NullType.

Then you just need a meta-functor:

template <typename T>
struct remove_const
{
    typedef T type;
};

template <typename T>
struct remove_const<const T>
{
    typedef T type;
};

Then put them together:

typedef TYPELIST_3(A, const B, B) TL;
typedef transform<TL, remove_const>::type TL2;
// TL2 is the same as TYPELIST_3(A, B, B)

_{It should be noted I haven't tried any of this.}