gcc/testsuite/g++.dg/cpp0x/variadic-lambda.C

   1 // { dg-do compile { target c++11 } }
   2
   3 struct int_placeholder;
   4
   5 template<typename T>
   6 struct do_replace
   7 {
   8   typedef T type;
   9 };
  10
  11 template<>
  12 struct do_replace<int_placeholder>
  13 {
  14   typedef int type;
  15 };
  16
  17 template<typename T> struct lambdalike
  18 {
  19   typedef T type;
  20 };
  21
  22 template<template<typename...> class TT, typename... Args>
  23 struct lambdalike<TT<Args...> > {
  24   typedef TT<typename do_replace<Args>::type...> type;
  25 };
  26
  27
  28 template<typename T, typename U>
  29 struct is_same
  30 {
  31   static const bool value = false;
  32 };
  33
  34 template<typename T>
  35 struct is_same<T, T>
  36 {
  37   static const bool value = true;
  38 };
  39
  40 template<typename... Elements> struct tuple;
  41 template<typename T1, typename T2> struct pair;
  42
  43 static_assert(is_same<lambdalike<tuple<float, int_placeholder, double>>::type,
  44                       tuple<float, int, double>>::value,
  45               "MPL lambda-like replacement on tuple");
  46 static_assert(is_same<lambdalike<pair<float, int_placeholder>>::type,
  47                       pair<float, int>>::value,
  48               "MPL lambda-like replacement on pair");
  49
  50
  51 struct _1 {};
  52
  53 template<typename Arg0, typename Lambda>
  54 struct eval
  55 {
  56     typedef Lambda type;
  57 };
  58
  59 template<typename Arg0>
  60 struct eval<Arg0, _1>
  61 {
  62     typedef Arg0 type;
  63 };
  64
  65 template<typename Arg0, template<typename...> class T, typename... Pack>
  66 struct eval<Arg0, T<Pack...> >
  67 {
  68     typedef T< typename eval<Arg0, Pack>::type... > type;
  69 };
  70
  71 static_assert(is_same<eval<int, tuple<float, _1, double>>::type,
  72                       tuple<float, int, double>>::value, "eval tuple");
  73 static_assert(is_same<eval<int, pair<_1, double>>::type,
  74                       pair<int, double>>::value, "eval pair");
  75 static_assert(is_same<eval<int,
  76                            tuple<pair<_1, _1>, pair<float, float>,
  77                                  pair<double, _1>>>::type,
  78               tuple<pair<int, int>, pair<float, float>, pair<double, int>>>::value,
  79               "recursive eval");