C++メタ関数のまとめ ref: https://qiita.com/_EnumHack/items/ee2141ad47915c55d9cb

file0.cpp

std::is_same<T,U>::value

file1.cpp

template < class T, T value >
class integral_constant;

file10.cpp

template < typename T >
struct is_pointer {
    static constexpr bool value = false ;
}
template < typename T >
struct is_int<T*> {
    static constexpr bool value = true ;
}

file11.cpp

template < typename T >
struct is_vector : std::false_type{};

template < typename T >
struct is_vector<std::vector<T>> : std::true_type {};

template < typename T >
constexpr bool is_vector_v = is_vector<T>::value;

file12.cpp

template < typename T >
struct is_tuple : std::false_type{};

template < typename ...Types >
struct is_tuple<std::tuple<Types...>> : std::true_type {};

template < typename T >
constexpr bool is_tuple_v = is_tuple<T>::value;

file13.cpp

template <class T>
class has_iterator {
  template <class U>
  static constexpr bool check(typename U::iterator*)
  { return true; }

  template <class U>
  static constexpr bool check(...)
  { return false; }
public:
  static constexpr bool value = check<T>(nullptr);
};

file14.cpp

template <class T>
class has_iterator {
  template <class U>
  static constexpr std::true_type check(typename U::iterator*);

  template <class U>
  static constexpr std::false_type check(...);

public:
  static constexpr bool value = decltype(check<T>(nullptr))::value;
};

file15.cpp

template <class T>
class has_iterator {
  template <class U, typename O = typename U::iterator>
  static constexpr std::true_type check(int);

  template <class U>
  static constexpr std::false_type check(long);

public:
  static constexpr bool value = decltype(check<T>(0))::value;
};

file16.cpp

struct has_iterator_impl {
  template <class T>
  static std::true_type check(typename T::iterator*);

  template <class T>
  static std::false_type check(...);
};

template <class T>
class has_iterator :
  public decltype(has_iterator_impl::check<T>(nullptr)) {};

file17.cpp

struct has_value_impl {
  template <class T>
  static std::true_type check(decltype(T::value)*);

  template <class T>
  static std::false_type check(...);
};

template <class T>
class has_value :
  public decltype(has_value_impl::check<T>(nullptr)) {};

file18.cpp

struct has_f_impl {
  template <class T>
  static auto check(T&& x)->decltype(x.f(),std::true_type{});

  template <class T>
  static auto check(...)->std::false_type;
};

template <class T>
class has_f :
  public decltype(has_f_impl::check<T>(std::declval<T>())) {};

file19.cpp

func_1( x, y + 2, z );
func_2( (x--, y + 2), z );

file2.cpp

integral_constant<class T, T value>

file20.cpp

struct has_value_impl {
  template <class T>
  static std::true_type check(decltype(&T::value));

  template <class T>
  static std::false_type check(...);
};

template <class T>
class has_value :
  public decltype(has_value_impl::check<T>(nullptr)) {};

file21.cpp

struct is_assignable_impl {
  template <class T>
  static auto check(T&& x, T const& y) -> decltype(x=y,std::true_type{});

  static auto check(...) -> std::false_type;
};

template <class T>
struct is_assignable
  : decltype(is_assignable_impl::check(std::declval<T>(),std::declval<T>())) {};

file22.cpp

template < typename T >
std::add_rvalue_reference<T> value() ;

file23.cpp

template<typename T, typename = void>
struct is_equality_comparable : std::false_type
{};

template<typename T>
struct is_equality_comparable<T,
    typename std::enable_if<
        true, 
        decltype(std::declval<T&>() == std::declval<T&>(), (void)0)
        >::type
    > : std::true_type
{};

file24.cpp

template < typename ... >
using void_t = void;

file25.cpp

template< class, class=void >
struct is_equality_comparable : std::false_type
{};

template< class T >
struct is_equality_comparable<T,
  void_t<decltype(std::declval<T&>() == std::declval<T&>() )>
  > : std::true_type
{};

file26.cpp

template <class,class=void>

file27.cpp

template <class T>

file28.cpp

struct is_equality_comparable<T,
  void_t<decltype(std::declval<T&>() == std::declval<T&>() )>

file29.cpp

std::begin(a), std::end(a)

file3.cpp

typename add_const<T>::type

file30.cpp

begin(a), end(a)

file31.cpp

template < typename T >
struct is_range : std::bool_constant<
  A<T>::value || B<T>::value
>{};

file32.cpp

#include <type_traits>
#include <utility>

namespace cranberries_magic{

  template < class, class=void >
  struct enable_std_begin_end : std::false_type {};

  template < typename T >
  struct enable_std_begin_end<T,
      std::void_t<decltype( std::begin(std::declval<const T&>()),std::end(std::declval<const T&>()) )>>
  : std::true_type {};

  template < class, class=void >
  struct enable_adl_begin_end : std::false_type {};

  template < typename T >
  struct enable_adl_begin_end<T,
      std::void_t<decltype( begin(std::declval<const T&>()),end(std::declval<const T&>()) )>>
  : std::true_type {};


} // ! namespace cranberries_magic

  template < typename T >
  struct is_range
    : std::bool_constant<
       cranberries_magic::enable_std_begin_end<T>::value
    || cranberries_magic::enable_adl_begin_end<T>::value>
  {};

  template < typename T >
  constexpr bool is_range_v = is_range<T>::value;

file33.cpp

  template < class, class=void >
  struct is_iterator : std::false_type {};

  template < typename T >
  struct is_iterator<T,
    std::enable_if_t<
      std::is_base_of<std::input_iterator_tag, typename std::iterator_traits<T>::iterator_category>::value
   || std::is_base_of<std::output_iterator_tag, typename std::iterator_traits<T>::iterator_category>::value
    >
  > : std::true_type
  {};

file34.cpp

// 全ての条件がtrueなら結果がtrueとなる
constexpr bool result1 = std::conjunction_v<
    std::true_type,
    std::is_void<void>,
    std::is_same<int,int>
>;

// 条件を否定する
constexpr bool result2 = std::negation_v<std::true_type>; // false

file35.cpp

template < typename T >
struct is_range
  : std::disjunction<
     detail::enable_std_begin_end<T>,
     detail::enable_adl_begin_end<T>>
{};

file36.cpp

template < typename T >
struct is_iterator : std::disjunction<
      std::is_base_of<std::input_iterator_tag, typename std::iterator_traits<T>::iterator_category>,
      std::is_base_of<std::output_iterator_tag, typename std::iterator_traits<T>::iterator_category>>
{};

file37.cpp

#include <type_traits>
#include <utility>
namespace cranberries {
  struct protean_bool {
    constexpr operator std::true_type() const { return{}; }
    constexpr operator std::false_type() const { return{}; }
  };

  template <class T, class... Ts>
  struct Overload : T, Overload<Ts...> {
    Overload(T a, Ts... xs): T{a}, Overload<Ts...>{xs...} {}
    using T::operator();
    using Overload<Ts...>::operator();
  };

  template <class T> struct Overload<T> : T {
    Overload(T a): T{a} {}
    using T::operator();
  };

  template <class... F>
  inline constexpr Overload<F...>
  make_overload(F&&... f)
  {
    return {{std::forward<F>(f)}...};
  }
  template <class T> struct type_placeholder{ using type = T; };
}
#define CRANBERRIES_HAS_TYPE(XXX, ...) \
  bool(false \
  ? ::cranberries::make_overload( \
    [](auto x)->decltype(std::declval<typename decltype(x)::type::XXX>(), std::true_type{}) {return{}; }, \
    [](...)->std::false_type {return{}; } \
  )(::cranberries::type_placeholder<__VA_ARGS__>{}) \
    : ::cranberries::protean_bool{})
int main()
{
    static_assert(CRANBERRIES_HAS_TYPE(value_type, std::true_type),"");
}

file38.cpp

static_assert(
  CRANBERRIES_HAS_TYPE(value_type, std::true_type), // true
  "");

file39.cpp

  template <class T, class... Ts>
  struct Overload : T, Overload<Ts...> {
    Overload(T a, Ts... xs): T{a}, Overload<Ts...>{xs...} {}
    using T::operator();
    using Overload<Ts...>::operator();
  };

  template <class T> struct Overload<T> : T {
    Overload(T a): T{a} {}
    using T::operator();
  };

file4.cpp

template < typename T >
using add_const_t = typename add_const<T>::type ;

file40.cpp

cranberries::make_overload(
    [](auto x)->decltype(std::declval<typename decltype(x)::type::XXX>(), std::true_type{}) {return{}; },
    [](...)->std::false_type {return{}; }
  )(::cranberries::type_placeholder<__VA_ARGS__>{})

file41.cpp

// ラムダ式は未評価式で使えないのでこれはダメ！
decltype(
cranberries::make_overload(
    [](auto x)->decltype(std::declval<typename decltype(x)::type::XXX>(), std::true_type{}) {return{}; },
    [](...)->std::false_type {return{}; }
  )(::cranberries::type_placeholder<SOME_TYPE>())
)::value

file42.cpp

  struct protean_bool {
    constexpr operator std::true_type() const { return{}; }
    constexpr operator std::false_type() const { return{}; }
  };

file43.cpp

false ? make_overload(...)(x) : cranberries::protean_bool{};

file5.cpp

template < typename T, typename U >
constexpr bool is_same_v = is_same<T,U>::value ;

file6.cpp

template <typename From, typename To>
struct is_convertible_basic_impl
{
    // 2 つの同名関数を作って
    static no_type _m_check(...);
    static yes_type _m_check(To);

    // 関数の戻り値の型を見る（どっちの関数が使われるかを見る）
    static bool value = sizeof( _m_check(From) ) == sizeof(yes_type);
};

file7.cpp

template < typename T >
typename T::value_type func(T);

file8.cpp

template < typename L, typename R >
auto plus(L&& l, R&& r) -> decltype(l+r)
{
  return l + r;
}

file9.cpp

template < typename T >
struct is_int {
    static constexpr bool value = false ;
}
template < >
struct is_int<int> {
    static constexpr bool value = true ;
}