The Nest
Explore
0
Compiler projects using llvm 
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics

// A simple cons-style typelist
struct nil { };

template<typename Head, typename Tail = nil>
struct cons { 
  typedef Head head;
  typedef Tail tail;
};

// is_same trait, for testing
template<typename T, typename U>
struct is_same {
  static const bool value = false;
};

template<typename T>
struct is_same<T, T> {
  static const bool value = true;
};

// metaprogram that computes the length of a list
template<typename T> struct length;

template<typename Head, typename Tail>
struct length<cons<Head, Tail> > {
  static const unsigned value = length<Tail>::value + 1;
};

template<>
struct length<nil> {
  static const unsigned value = 0;
};

typedef cons<unsigned char, 
             cons<unsigned short, 
                  cons<unsigned int,
                       cons<unsigned long> > > > unsigned_inttypes;
int length0[length<unsigned_inttypes>::value == 4? 1 : -1];

// metaprogram that reverses a list

// FIXME: I would prefer that this be a partial specialization, but
// that requires partial ordering of class template partial
// specializations.
template<typename T> 
class reverse {
  typedef typename reverse<typename T::tail>::type reversed_tail;

  typedef typename reverse<typename reversed_tail::tail>::type most_of_tail;

public:
  typedef cons<typename reversed_tail::head,
               typename reverse<cons<typename T::head, most_of_tail> >::type> type;
};

template<typename Head>
class reverse<cons<Head> > {
public:
  typedef cons<Head> type;
};

template<>
class reverse<nil> {
public:
  typedef nil type;
};

int reverse0[is_same<reverse<unsigned_inttypes>::type,
                     cons<unsigned long, 
                          cons<unsigned int, 
                               cons<unsigned short,
                                    cons<unsigned char> > > > >::value? 1 : -1];

// metaprogram that finds a type within a list

// FIXME: I would prefer that this be a partial specialization, but
// that requires partial ordering of class template partial
// specializations.
template<typename List, typename T>
struct find : find<typename List::tail, T> { };

template<typename Tail, typename T>
struct find<cons<T, Tail>, T> {
  typedef cons<T, Tail> type;
};

template<typename T>
struct find<nil, T> {
  typedef nil type;
};

int find0[is_same<find<unsigned_inttypes, unsigned int>::type,
                       cons<unsigned int, cons<unsigned long> > >::value?
             1 : -1];
int find1[is_same<find<unsigned_inttypes, int>::type, nil>::value? 1 : -1];