More template metaprogramming fun.... (G++/Comeau disagree)

I've been trying out more template metaprogramming ideas with typelists
(mostly for personal learning, I'm aware boost most probably provides
this facility already), and I've run into this small problem here.

Comeau online (without C++0x, in strict mode) accepts this example
pasted here, (apologies for the length of it). Unfortunately G++ (3.4,
4.1, 4.2) doesn't, and complains about index_find being private. The
exact error it gives is:

test.cc:21: error: 'template<class T, class N> template<class X, class
O> class typelist<T, N>::index_find' is private
test.cc:21: error: within this context

Which seems to imply I've gotten the friend declaration wrong. Is my
syntax correct for this? Can somebody point me in the direction of a
definitive answer on this one? Obviously if I make index_find public
then this whole problem goes away, but given that it's part of the
internal implementation mechanism, rather than the public interface I'd
rather keep it private, and hopefully learn which compiler is
right/wrong in this instance. I was quite surprised g++ rejected this
when Comeau accepts it.

Thanks,
Alan

#include <typeinfo>
#include <cassert>

// Utility for comparing two types
template <typename A, typename B>
class compare_types {
public:
    enum { is_same = 0 };
};

// and corresponding the partial specialisation
template <typename A>
class compare_types<A,A> {
public:
    enum { is_same = 1 };
};

template <typename T, typename N=void>
class typelist {
    template <typename X, typename O>
    class index_find;

    template <typename U, typename M>
    template <typename X, typename O>
    friend class typelist<U,M>::index_find;
public:
    typedef T type;
    typedef N next;

    /**
     * Constant value used to indicate that a type was not found during
a search of a typelist
    */
    enum { not_found=~0 };

private:
    template <typename X, typename O>
    class index_find {
    public:
        // If we are a match end recursion with a 0.
        // If we aren't a match carry on recursively searching.
        // If our recursive search returns failure then we should return
failure also.
        enum { index=compare_types<X,T>::is_same ? 0 :
((static_cast<int>(N::template index_find<X, typename N::next>::index)
!= static_cast<int>(not_found))
                ? 1 + N::template index_find<X, typename N::next>::index
            : not_found) };
    };

    template <typename X>
    class index_find<X, void> {
    public:
        // If we are a match end recursion with a 0 index.
        // If we aren't a match we can't recurse any further since we
are the tail, so propagate not_found back.
        enum { index=compare_types<X,T>::is_same ? 0 : not_found };
    };
public:
    /**
     * Use this to search to see if a typelist contains a specified
type. Returns the index
     * it was (first if a type appears more than once) found at, or
not_found otherwise.
     */
    template <typename X>
    class index_of {
    public:
        enum { index=index_find<X,N>::index };
    };
};

// make sure we instantiate the templates here:
int main() {
    typedef typelist<float, typelist<int, typelist<char> > > list1;
    assert(static_cast<int>(list1::not_found) ==
static_cast<int>(list1::index_of<double>::index));
    assert(0 == static_cast<int>(list1::index_of<float>::index));
    assert(1 == static_cast<int>(list1::index_of<int>::index));
    assert(2 == static_cast<int>(list1::index_of<char>::index));

    return 0;
}