[libc++][NFC] Refactor return type enable_ifs to defaulted template arguments

[philnik]

Summary

This brings most of the enable_ifs in libc++ to the same style. It also has the nice side-effect of reducing the size of names of these symbols, since the depedent return type is shorter.

[philnik]

Fix formatting

[philnik]

Try to fix CI

[philnik]

Fix some _LIBCPP_INLINE_VISIBILITY posisitions

[ldionne]

LGTM. CI is green, it's just AIX.

libcxx/include/__algorithm/copy_n.h

 #include <__utility/convert_to_integral.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _InputIterator, class _Size, class _OutputIterator>
+template<class _InputIterator, class _Size, class _OutputIterator,
+         __enable_if_t<__has_input_iterator_category<_InputIterator>::value &&
+                       !__has_random_access_iterator_category<_InputIterator>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    __has_input_iterator_category<_InputIterator>::value &&
-   !__has_random_access_iterator_category<_InputIterator>::value,
-    _OutputIterator
->::type
 copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
 {
     typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
     _IntegralSize __n = __orig_n;
     if (__n > 0)
     {
         *__result = *__first;
         ++__result;
         for (--__n; __n > 0; --__n)
         {
             ++__first;
             *__result = *__first;
             ++__result;
         }
     }
     return __result;
 }
 
-template<class _InputIterator, class _Size, class _OutputIterator>
+template<class _InputIterator, class _Size, class _OutputIterator,
+         __enable_if_t<__has_random_access_iterator_category<_InputIterator>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    __has_random_access_iterator_category<_InputIterator>::value,
-    _OutputIterator
->::type
 copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
 {
     typedef typename iterator_traits<_InputIterator>::difference_type difference_type;
     typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
     _IntegralSize __n = __orig_n;
     return _VSTD::copy(__first, __first + difference_type(__n), __result);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_COPY_N_H

libcxx/include/__algorithm/half_positive.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Perform division by two quickly for positive integers (llvm.org/PR39129)
 
-template <typename _Integral>
+template <typename _Integral, __enable_if_t<is_integral<_Integral>::value, int> = 0>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    is_integral<_Integral>::value,
-    _Integral
->::type
 __half_positive(_Integral __value)
 {
     return static_cast<_Integral>(static_cast<__make_unsigned_t<_Integral> >(__value) / 2);
 }
 
-template <typename _Tp>
+template <typename _Tp, __enable_if_t<!is_integral<_Tp>::value, int> = 0>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    !is_integral<_Tp>::value,
-    _Tp
->::type
 __half_positive(_Tp __value)
 {
     return __value / 2;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_HALF_POSITIVE_H

libcxx/include/__atomic/atomic.h

 _LIBCPP_HIDE_FROM_ABI
 _Tp atomic_fetch_sub_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_sub(__op, __m);
 }
 
 // atomic_fetch_and
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_and(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_and(__op);
 }
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_and(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_and(__op);
 }
 
 // atomic_fetch_and_explicit
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_and_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_and(__op, __m);
 }
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_and_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_and(__op, __m);
 }
 
 // atomic_fetch_or
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_or(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_or(__op);
 }
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_or(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_or(__op);
 }
 
 // atomic_fetch_or_explicit
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_or_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_or(__op, __m);
 }
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_or_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_or(__op, __m);
 }
 
 // atomic_fetch_xor
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_xor(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_xor(__op);
 }
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_xor(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_xor(__op);
 }
 
 // atomic_fetch_xor_explicit
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_xor_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_xor(__op, __m);
 }
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
 atomic_fetch_xor_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_xor(__op, __m);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ATOMIC_ATOMIC_H

libcxx/include/__atomic/cxx_atomic_impl.h

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP) || \
     defined(_LIBCPP_ATOMIC_ONLY_USE_BUILTINS)
 
 // [atomics.types.generic]p1 guarantees _Tp is trivially copyable. Because
 // the default operator= in an object is not volatile, a byte-by-byte copy
 // is required.
-template <typename _Tp, typename _Tv> _LIBCPP_HIDE_FROM_ABI
-typename enable_if<is_assignable<_Tp&, _Tv>::value>::type
-__cxx_atomic_assign_volatile(_Tp& __a_value, _Tv const& __val) {
+template <typename _Tp, typename _Tv, __enable_if_t<is_assignable<_Tp&, _Tv>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI
+void __cxx_atomic_assign_volatile(_Tp& __a_value, _Tv const& __val) {
   __a_value = __val;
 }
-template <typename _Tp, typename _Tv> _LIBCPP_HIDE_FROM_ABI
-typename enable_if<is_assignable<_Tp&, _Tv>::value>::type
-__cxx_atomic_assign_volatile(_Tp volatile& __a_value, _Tv volatile const& __val) {
+template <typename _Tp, typename _Tv, __enable_if_t<is_assignable<_Tp&, _Tv>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI
+void __cxx_atomic_assign_volatile(_Tp volatile& __a_value, _Tv volatile const& __val) {
   volatile char* __to         = reinterpret_cast<volatile char*>(std::addressof(__a_value));
   volatile char* __end = __to + sizeof(_Tp);
   volatile const char* __from = reinterpret_cast<volatile const char*>(std::addressof(__val));
   while (__to != __end)
     *__to++ = *__from++;
 }
 
 #endif

libcxx/include/__chrono/duration.h

struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
     {
         typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
         return _ToDuration(static_cast<typename _ToDuration::rep>(
                            static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)
                                                           / static_cast<_Ct>(_Period::den)));
     }
 };
 
-template <class _ToDuration, class _Rep, class _Period>
+template <class _ToDuration, class _Rep, class _Period, __enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    _ToDuration
->::type
 duration_cast(const duration<_Rep, _Period>& __fd)
 {
     return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
 }
 
 template <class _Rep>
 struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Rep>
 inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value;
 #endif
 
 template <class _Rep>
 struct _LIBCPP_TEMPLATE_VIS duration_values
 {
 public:
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT {return _Rep(0);}
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max()  _NOEXCEPT {return numeric_limits<_Rep>::max();}
     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min()  _NOEXCEPT {return numeric_limits<_Rep>::lowest();}
 };
 
 #if _LIBCPP_STD_VER >= 17
-template <class _ToDuration, class _Rep, class _Period>
+template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    _ToDuration
->::type
 floor(const duration<_Rep, _Period>& __d)
 {
     _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
     if (__t > __d)
         __t = __t - _ToDuration{1};
     return __t;
 }
 
-template <class _ToDuration, class _Rep, class _Period>
+template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    _ToDuration
->::type
 ceil(const duration<_Rep, _Period>& __d)
 {
     _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
     if (__t < __d)
         __t = __t + _ToDuration{1};
     return __t;
 }
 
-template <class _ToDuration, class _Rep, class _Period>
+template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    _ToDuration
->::type
 round(const duration<_Rep, _Period>& __d)
 {
     _ToDuration __lower = chrono::floor<_ToDuration>(__d);
     _ToDuration __upper = __lower + _ToDuration{1};
     auto __lower_diff   = __d - __lower;
     auto __upper_diff   = __upper - __d;
     if (__lower_diff < __upper_diff)
         return __lower;

 operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 {
     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
     return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
 }
 
 // Duration *
 
-template <class _Rep1, class _Period, class _Rep2>
+template <class _Rep1, class _Period, class _Rep2,
+          __enable_if_t<is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
-    duration<typename common_type<_Rep1, _Rep2>::type, _Period>
->::type
 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 {
     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
     typedef duration<_Cr, _Period> _Cd;
     return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
 }
 
-template <class _Rep1, class _Period, class _Rep2>
+template <class _Rep1, class _Period, class _Rep2,
+          __enable_if_t<is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value,
-    duration<typename common_type<_Rep1, _Rep2>::type, _Period>
->::type
 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
 {
     return __d * __s;
 }
 
 // Duration /
 
-template <class _Rep1, class _Period, class _Rep2>
+template <class _Rep1, class _Period, class _Rep2,
+          __enable_if_t<!__is_duration<_Rep2>::value && is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    !__is_duration<_Rep2>::value &&
-      is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
-    duration<typename common_type<_Rep1, _Rep2>::type, _Period>
->::type
 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 {
     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
     typedef duration<_Cr, _Period> _Cd;
     return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
 }
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 typename common_type<_Rep1, _Rep2>::type
 operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 {
     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
     return _Ct(__lhs).count() / _Ct(__rhs).count();
 }
 
 // Duration %
 
-template <class _Rep1, class _Period, class _Rep2>
+template <class _Rep1, class _Period, class _Rep2,
+          __enable_if_t<!__is_duration<_Rep2>::value && is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    !__is_duration<_Rep2>::value &&
-      is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
-    duration<typename common_type<_Rep1, _Rep2>::type, _Period>
->::type
 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 {
     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
     typedef duration<_Cr, _Period> _Cd;
     return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
 }
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>

libcxx/include/__chrono/time_point.h

 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 time_point<_Clock, _ToDuration>
 time_point_cast(const time_point<_Clock, _Duration>& __t)
 {
     return time_point<_Clock, _ToDuration>(chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
 }
 
 #if _LIBCPP_STD_VER >= 17
-template <class _ToDuration, class _Clock, class _Duration>
+template <class _ToDuration, class _Clock, class _Duration, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    time_point<_Clock, _ToDuration>
->::type
 floor(const time_point<_Clock, _Duration>& __t)
 {
     return time_point<_Clock, _ToDuration>{chrono::floor<_ToDuration>(__t.time_since_epoch())};
 }
 
-template <class _ToDuration, class _Clock, class _Duration>
+template <class _ToDuration, class _Clock, class _Duration, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    time_point<_Clock, _ToDuration>
->::type
 ceil(const time_point<_Clock, _Duration>& __t)
 {
     return time_point<_Clock, _ToDuration>{chrono::ceil<_ToDuration>(__t.time_since_epoch())};
 }
 
-template <class _ToDuration, class _Clock, class _Duration>
+template <class _ToDuration, class _Clock, class _Duration, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    time_point<_Clock, _ToDuration>
->::type
 round(const time_point<_Clock, _Duration>& __t)
 {
     return time_point<_Clock, _ToDuration>{chrono::round<_ToDuration>(__t.time_since_epoch())};
 }
 
-template <class _Rep, class _Period>
+template <class _Rep, class _Period, enable_if_t<numeric_limits<_Rep>::is_signed, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    numeric_limits<_Rep>::is_signed,
-    duration<_Rep, _Period>
->::type
 abs(duration<_Rep, _Period> __d)
 {
     return __d >= __d.zero() ? +__d : -__d;
 }
 #endif // _LIBCPP_STD_VER >= 17
 
 // time_point ==
 

libcxx/include/__filesystem/path.h

struct __can_convert_char<char16_t> {
   using __char_type = char16_t;
 };
 template <>
 struct __can_convert_char<char32_t> {
   static const bool value = true;
   using __char_type = char32_t;
 };
 
-template <class _ECharT>
+template <class _ECharT, __enable_if_t<__can_convert_char<_ECharT>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI
-typename enable_if<__can_convert_char<_ECharT>::value, bool>::type
+bool
 __is_separator(_ECharT __e) {
 #if defined(_LIBCPP_WIN32API)
   return __e == _ECharT('/') || __e == _ECharT('\\');
 #else
   return __e == _ECharT('/');
 #endif
 }
 
__append_range(__dest, _Traits::__range_begin(__s),
                    _Traits::__range_end(__s));
   }
 };
 #endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
 template <>
 struct _PathCVT<__path_value> {
 
-  template <class _Iter>
+  template <class _Iter, __enable_if_t<__has_exactly_input_iterator_category<_Iter>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI
-  static typename enable_if<__has_exactly_input_iterator_category<_Iter>::value>::type
+  static void
   __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
     for (; __b != __e; ++__b)
       __dest.push_back(*__b);
   }
 
-  template <class _Iter>
+  template <class _Iter, __enable_if_t<__has_forward_iterator_category<_Iter>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI
-  static typename enable_if<__has_forward_iterator_category<_Iter>::value>::type
+  static void
   __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
     __dest.append(__b, __e);
   }
 
   template <class _Iter>
   _LIBCPP_HIDE_FROM_ABI
   static void __append_range(__path_string& __dest, _Iter __b, _NullSentinel) {
     const char __sentinel = char{};
struct _PathCVT<char> {
   static void
   __append_string(__path_string& __dest, const basic_string<char> &__str) {
       size_t __size = __char_to_wide(__str, nullptr, 0);
       size_t __pos = __dest.size();
       __dest.resize(__pos + __size);
       __char_to_wide(__str, const_cast<__path_value*>(__dest.data()) + __pos, __size);
   }
 
-  template <class _Iter>
+  template <class _Iter, __enable_if_t<__has_exactly_input_iterator_category<_Iter>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI
-  static typename enable_if<__has_exactly_input_iterator_category<_Iter>::value>::type
+  static void
   __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
     basic_string<char> __tmp(__b, __e);
     __append_string(__dest, __tmp);
   }
 
-  template <class _Iter>
+  template <class _Iter, __enable_if_t<__has_forward_iterator_category<_Iter>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI
-  static typename enable_if<__has_forward_iterator_category<_Iter>::value>::type
+  static void
   __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
     basic_string<char> __tmp(__b, __e);
     __append_string(__dest, __tmp);
   }
 
   template <class _Iter>
   _LIBCPP_HIDE_FROM_ABI
   static void __append_range(__path_string& __dest, _Iter __b, _NullSentinel) {
#endif
   }
 
   _LIBCPP_HIDE_FROM_ABI
   path& operator+=(value_type __x) {
     __pn_ += __x;
     return *this;
   }
 
-  template <class _ECharT>
+  template <class _ECharT, __enable_if_t<__can_convert_char<_ECharT>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI
-  typename enable_if<__can_convert_char<_ECharT>::value, path&>::type
+  path&
   operator+=(_ECharT __x) {
     _PathCVT<_ECharT>::__append_source(__pn_,
                                        basic_string_view<_ECharT>(&__x, 1));
     return *this;
   }
 
   template <class _Source>
   _LIBCPP_HIDE_FROM_ABI
#endif
   // iterators
   class _LIBCPP_EXPORTED_FROM_ABI iterator;
   typedef iterator const_iterator;
 
   iterator begin() const;
   iterator end() const;
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-  template <class _CharT, class _Traits>
+  template <class _CharT, class _Traits, __enable_if_t<is_same<_CharT, value_type>::value &&
+                                                       is_same<_Traits, char_traits<value_type> >::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI friend
-      typename enable_if<is_same<_CharT, value_type>::value &&
-                             is_same<_Traits, char_traits<value_type> >::value,
-                         basic_ostream<_CharT, _Traits>&>::type
+  basic_ostream<_CharT, _Traits>&
       operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
     __os << _VSTD::__quoted(__p.native());
     return __os;
   }
 
-  template <class _CharT, class _Traits>
+  template <class _CharT, class _Traits, __enable_if_t<!is_same<_CharT, value_type>::value ||
+                                                       !is_same<_Traits, char_traits<value_type> >::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI friend
-      typename enable_if<!is_same<_CharT, value_type>::value ||
-                             !is_same<_Traits, char_traits<value_type> >::value,
-                         basic_ostream<_CharT, _Traits>&>::type
+  basic_ostream<_CharT, _Traits>&
       operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
     __os << _VSTD::__quoted(__p.string<_CharT, _Traits>());
     return __os;
   }
 
   template <class _CharT, class _Traits>
   _LIBCPP_HIDE_FROM_ABI friend basic_istream<_CharT, _Traits>&
   operator>>(basic_istream<_CharT, _Traits>& __is, path& __p) {

libcxx/include/__filesystem/u8path.h

 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 
-template <class _InputIt>
+template <class _InputIt, __enable_if_t<__is_pathable<_InputIt>::value, int> = 0>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
-    typename enable_if<__is_pathable<_InputIt>::value, path>::type
+    path
     u8path(_InputIt __f, _InputIt __l) {
   static_assert(
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
       is_same<typename __is_pathable<_InputIt>::__char_type, char8_t>::value ||
 #endif
       is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
       "u8path(Iter, Iter) requires Iter have a value_type of type 'char'"
       " or 'char8_t'");
 #if defined(_LIBCPP_WIN32API)
   string __tmp(__f, __l);
   using _CVT = __widen_from_utf8<sizeof(wchar_t) * __CHAR_BIT__>;
   _VSTD::wstring __w;
   __w.reserve(__tmp.size());
   _CVT()(back_inserter(__w), __tmp.data(), __tmp.data() + __tmp.size());
   return path(__w);
 #else
   return path(__f, __l);
 #endif /* !_LIBCPP_WIN32API */
 }
 
 #if defined(_LIBCPP_WIN32API)
-template <class _InputIt>
+template <class _InputIt, __enable_if_t<__is_pathable<_InputIt>::value, int> = 0>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
-    typename enable_if<__is_pathable<_InputIt>::value, path>::type
+    path
     u8path(_InputIt __f, _NullSentinel) {
   static_assert(
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
       is_same<typename __is_pathable<_InputIt>::__char_type, char8_t>::value ||
 #endif
       is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
       "u8path(Iter, Iter) requires Iter have a value_type of type 'char'"
       " or 'char8_t'");
   string __tmp;
   const char __sentinel = char{};
   for (; *__f != __sentinel; ++__f)
     __tmp.push_back(*__f);
   using _CVT = __widen_from_utf8<sizeof(wchar_t) * __CHAR_BIT__>;
   _VSTD::wstring __w;
   __w.reserve(__tmp.size());
   _CVT()(back_inserter(__w), __tmp.data(), __tmp.data() + __tmp.size());
   return path(__w);
 }
 #endif /* _LIBCPP_WIN32API */
 
-template <class _Source>
+template <class _Source, __enable_if_t<__is_pathable<_Source>::value, int> = 0>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
-    typename enable_if<__is_pathable<_Source>::value, path>::type
+    path
     u8path(const _Source& __s) {
   static_assert(
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
       is_same<typename __is_pathable<_Source>::__char_type, char8_t>::value ||
 #endif
       is_same<typename __is_pathable<_Source>::__char_type, char>::value,
       "u8path(Source const&) requires Source have a character type of type "
       "'char' or 'char8_t'");

libcxx/include/__functional/bind.h

 struct __mu_return2 {};
 
 template <class _Ti, class _Uj>
 struct __mu_return2<true, _Ti, _Uj>
 {
     typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
 };
 
-template <class _Ti, class _Uj>
+template <class _Ti, class _Uj, __enable_if_t<0 < is_placeholder<_Ti>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    0 < is_placeholder<_Ti>::value,
-    typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
->::type
 __mu(_Ti&, _Uj& __uj)
 {
     const size_t __indx = is_placeholder<_Ti>::value - 1;
     return _VSTD::forward<typename tuple_element<__indx, _Uj>::type>(_VSTD::get<__indx>(__uj));
 }
 
-template <class _Ti, class _Uj>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    !is_bind_expression<_Ti>::value &&
+template <class _Ti, class _Uj, __enable_if_t<!is_bind_expression<_Ti>::value &&
                                               is_placeholder<_Ti>::value == 0 &&
-    !__is_reference_wrapper<_Ti>::value,
-    _Ti&
->::type
+                                              !__is_reference_wrapper<_Ti>::value, int> = 0>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
 __mu(_Ti& __ti, _Uj&)
 {
     return __ti;
 }
 
 template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
           class _TupleUj>
 struct __mu_return_impl;
template <class _Gp, class ..._BA,
                                   !is_same<__libcpp_remove_reference_t<_Gp>,
                                            __bind_r>::value
                                >::type>
       _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
       explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
         : base(_VSTD::forward<_Gp>(__f),
                _VSTD::forward<_BA>(__bound_args)...) {}
 
-    template <class ..._Args>
+    template <class ..._Args, __enable_if_t<is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
+                                                           result_type>::value || is_void<_Rp>::value, int> = 0>
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-        typename enable_if
-        <
-            is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
-                           result_type>::value || is_void<_Rp>::value,
-            result_type
-        >::type
         operator()(_Args&& ...__args)
         {
             typedef __invoke_void_return_wrapper<_Rp> _Invoker;
             return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);
         }
 
-    template <class ..._Args>
+    template <class ..._Args, __enable_if_t<is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
+                                                           result_type>::value || is_void<_Rp>::value, int> = 0>
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-        typename enable_if
-        <
-            is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
-                           result_type>::value || is_void<_Rp>::value,
-            result_type
-        >::type
         operator()(_Args&& ...__args) const
         {
             typedef __invoke_void_return_wrapper<_Rp> _Invoker;
             return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);
         }
 };
 
 template<class _Rp, class _Fp, class ..._BoundArgs>

libcxx/include/__iterator/next.h

 #include <__type_traits/enable_if.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIter>
+template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    typename enable_if<__has_input_iterator_category<_InputIter>::value, _InputIter>::type
+    _InputIter
     next(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
   _LIBCPP_ASSERT_UNCATEGORIZED(__n >= 0 || __has_bidirectional_iterator_category<_InputIter>::value,
                                "Attempt to next(it, n) with negative n on a non-bidirectional iterator");
 
   _VSTD::advance(__x, __n);
   return __x;
 }
 

libcxx/include/__iterator/prev.h

 #include <__type_traits/enable_if.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIter>
+template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    typename enable_if<__has_input_iterator_category<_InputIter>::value, _InputIter>::type
+    _InputIter
     prev(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
   _LIBCPP_ASSERT_UNCATEGORIZED(__n <= 0 || __has_bidirectional_iterator_category<_InputIter>::value,
                                "Attempt to prev(it, n) with a positive n on a non-bidirectional iterator");
   _VSTD::advance(__x, -__n);
   return __x;
 }
 
 #if _LIBCPP_STD_VER >= 20

libcxx/include/__memory/shared_ptr.h

public:
     weak_ptr(weak_ptr&& __r) _NOEXCEPT;
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r,
                    typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = 0)
                          _NOEXCEPT;
     _LIBCPP_HIDE_FROM_ABI ~weak_ptr();
 
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT;
-    template<class _Yp>
-        typename enable_if
-        <
-            __compatible_with<_Yp, _Tp>::value,
-            weak_ptr&
-        >::type
-        _LIBCPP_INLINE_VISIBILITY
+    template<class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY weak_ptr&
         operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT;
-    template<class _Yp>
-        typename enable_if
-        <
-            __compatible_with<_Yp, _Tp>::value,
-            weak_ptr&
-        >::type
-        _LIBCPP_INLINE_VISIBILITY
+    template<class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY weak_ptr&
         operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT;
 
-    template<class _Yp>
-        typename enable_if
-        <
-            __compatible_with<_Yp, _Tp>::value,
-            weak_ptr&
-        >::type
-        _LIBCPP_INLINE_VISIBILITY
+    template<class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY weak_ptr&
         operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(weak_ptr& __r) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     void reset() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY

 weak_ptr<_Tp>&
 weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
-template<class _Yp>
+template<class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
 inline
-typename enable_if
-<
-    __compatible_with<_Yp, _Tp>::value,
-    weak_ptr<_Tp>&
->::type
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 inline
 weak_ptr<_Tp>&
 weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT
 {
     weak_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 template<class _Tp>
-template<class _Yp>
+template<class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
 inline
-typename enable_if
-<
-    __compatible_with<_Yp, _Tp>::value,
-    weak_ptr<_Tp>&
->::type
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT
 {
     weak_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 template<class _Tp>
-template<class _Yp>
+template<class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
 inline
-typename enable_if
-<
-    __compatible_with<_Yp, _Tp>::value,
-    weak_ptr<_Tp>&
->::type
 weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 inline

libcxx/include/__memory/unique_ptr.h

template <class _Up,
             class = _EnableIfDeleterAssignable<_Ep> >
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
     return *this;
   }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
-  template <class _Up>
+  template <class _Up, __enable_if_t<is_convertible<_Up*, _Tp*>::value &&
+                                     is_same<_Dp, default_delete<_Tp> >::value, int> = 0>
   _LIBCPP_INLINE_VISIBILITY
-      typename enable_if<is_convertible<_Up*, _Tp*>::value &&
-                             is_same<_Dp, default_delete<_Tp> >::value,
-                         unique_ptr&>::type
+  unique_ptr&
       operator=(auto_ptr<_Up> __p) {
     reset(__p.release());
     return *this;
   }
 #endif
 
 #ifdef _LIBCPP_CXX03_LANG
   unique_ptr(unique_ptr const&) = delete;
public:
   }
 
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer release() _NOEXCEPT {
     pointer __t = __ptr_.first();
     __ptr_.first() = pointer();
     return __t;
   }
 
-  template <class _Pp>
+  template <class _Pp, __enable_if_t<_CheckArrayPointerConversion<_Pp>::value, int> = 0>
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-      typename enable_if< _CheckArrayPointerConversion<_Pp>::value >::type
-      reset(_Pp __p) _NOEXCEPT {
+  void reset(_Pp __p) _NOEXCEPT {
     pointer __tmp = __ptr_.first();
     __ptr_.first() = __p;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void reset(nullptr_t = nullptr) _NOEXCEPT {
     pointer __tmp = __ptr_.first();
     __ptr_.first() = nullptr;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void swap(unique_ptr& __u) _NOEXCEPT {
     __ptr_.swap(__u.__ptr_);
   }
 };
 
-template <class _Tp, class _Dp>
+template <class _Tp, class _Dp, __enable_if_t<__is_swappable<_Dp>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    typename enable_if< __is_swappable<_Dp>::value, void >::type
+    void
     swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {
   __x.swap(__y);
 }
 
 template <class _T1, class _D1, class _T2, class _D2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
 operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {
   return __x.get() == __y.get();

libcxx/include/__random/discard_block_engine.h

template<class _Sseq>
         explicit discard_block_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value &&
                            !is_convertible<_Sseq, _Engine>::value>::type* = 0)
         : __e_(__q), __n_(0) {}
     _LIBCPP_INLINE_VISIBILITY
     void seed() {__e_.seed(); __n_ = 0;}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;}
-    template<class _Sseq>
+    template<class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, discard_block_engine>::value, int> = 0>
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, discard_block_engine>::value,
-            void
-        >::type
         seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;}
 
     // generating functions
     _LIBCPP_HIDE_FROM_ABI result_type operator()();
     _LIBCPP_INLINE_VISIBILITY
     void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
 
     // property functions

libcxx/include/__random/independent_bits_engine.h

template<class _Sseq>
         explicit independent_bits_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value &&
                            !is_convertible<_Sseq, _Engine>::value>::type* = 0)
          : __e_(__q) {}
     _LIBCPP_INLINE_VISIBILITY
     void seed() {__e_.seed();}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __sd) {__e_.seed(__sd);}
-    template<class _Sseq>
+    template<class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, independent_bits_engine>::value, int> = 0>
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, independent_bits_engine>::value,
-            void
-        >::type
         seed(_Sseq& __q) {__e_.seed(__q);}
 
     // generating functions
     _LIBCPP_INLINE_VISIBILITY
     result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
     _LIBCPP_INLINE_VISIBILITY
     void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
 
#endif // _LIBCPP_CXX03_LANG
     operator>>(basic_istream<_CharT, _Traits>& __is,
                independent_bits_engine<_Eng, _Wp, _UInt>& __x);
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     result_type __eval(false_type);
     _LIBCPP_HIDE_FROM_ABI result_type __eval(true_type);
 
-    template <size_t __count>
+    template <size_t __count, __enable_if_t<__count < _Dt, int> = 0>
         _LIBCPP_INLINE_VISIBILITY
         static
-        typename enable_if
-        <
-            __count < _Dt,
-            result_type
-        >::type
         __lshift(result_type __x) {return __x << __count;}
 
-    template <size_t __count>
+    template <size_t __count, __enable_if_t<(__count >= _Dt), int> = 0>
         _LIBCPP_INLINE_VISIBILITY
         static
-        typename enable_if
-        <
-            (__count >= _Dt),
-            result_type
-        >::type
         __lshift(result_type) {return result_type(0);}
 };
 
 template<class _Engine, size_t __w, class _UIntType>
 inline
 _UIntType
 independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type)
 {

libcxx/include/__random/linear_congruential_engine.h

template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit linear_congruential_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0)
         {seed(__q);}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __s = default_seed)
         {seed(integral_constant<bool, __m == 0>(),
               integral_constant<bool, __c == 0>(), __s);}
-    template<class _Sseq>
+    template<class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, linear_congruential_engine>::value, int> = 0>
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, linear_congruential_engine>::value,
-            void
-        >::type
         seed(_Sseq& __q)
             {__seed(__q, integral_constant<unsigned,
                 1 + (__m == 0 ? (sizeof(result_type) * __CHAR_BIT__ - 1)/32
                              :  (__m > 0x100000000ull))>());}
 
     // generating functions
     _LIBCPP_INLINE_VISIBILITY
     result_type operator()()

libcxx/include/__random/mersenne_twister_engine.h

#else
     }
 #endif
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit mersenne_twister_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
         {seed(__q);}
     _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd = default_seed);
-    template<class _Sseq>
+    template<class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value, int> = 0>
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, mersenne_twister_engine>::value,
-            void
-        >::type
         seed(_Sseq& __q)
             {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
 
     // generating functions
     _LIBCPP_HIDE_FROM_ABI result_type operator()();
     _LIBCPP_INLINE_VISIBILITY
     void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
 
operator>>(basic_istream<_CharT, _Traits>& __is,
                                        _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
 private:
 
     template<class _Sseq>
     _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
     template<class _Sseq>
     _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
 
-    template <size_t __count>
+    template <size_t __count, __enable_if_t<__count < __w, int> = 0>
         _LIBCPP_INLINE_VISIBILITY
         static
-        typename enable_if
-        <
-            __count < __w,
-            result_type
-        >::type
         __lshift(result_type __x) {return (__x << __count) & _Max;}
 
-    template <size_t __count>
+    template <size_t __count, __enable_if_t<(__count >= __w), int> = 0>
         _LIBCPP_INLINE_VISIBILITY
         static
-        typename enable_if
-        <
-            (__count >= __w),
-            result_type
-        >::type
         __lshift(result_type) {return result_type(0);}
 
-    template <size_t __count>
+    template <size_t __count, __enable_if_t<__count < _Dt, int> = 0>
         _LIBCPP_INLINE_VISIBILITY
         static
-        typename enable_if
-        <
-            __count < _Dt,
-            result_type
-        >::type
         __rshift(result_type __x) {return __x >> __count;}
 
-    template <size_t __count>
+    template <size_t __count, __enable_if_t<(__count >= _Dt), int> = 0>
         _LIBCPP_INLINE_VISIBILITY
         static
-        typename enable_if
-        <
-            (__count >= _Dt),
-            result_type
-        >::type
         __rshift(result_type) {return result_type(0);}
 };
 
 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
     _LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size;

libcxx/include/__random/shuffle_order_engine.h

template<class _Sseq>
         explicit shuffle_order_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value &&
                            !is_convertible<_Sseq, _Engine>::value>::type* = 0)
          : __e_(__q) {__init();}
     _LIBCPP_INLINE_VISIBILITY
     void seed() {__e_.seed(); __init();}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __sd) {__e_.seed(__sd); __init();}
-    template<class _Sseq>
+    template<class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, shuffle_order_engine>::value, int> = 0>
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, shuffle_order_engine>::value,
-            void
-        >::type
         seed(_Sseq& __q) {__e_.seed(__q); __init();}
 
     // generating functions
     _LIBCPP_INLINE_VISIBILITY
     result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
     _LIBCPP_INLINE_VISIBILITY
     void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
 
private:
     _LIBCPP_INLINE_VISIBILITY
     result_type __eval(true_type) {return __eval(__uratio<__k, _Rp>());}
 
     _LIBCPP_INLINE_VISIBILITY
     result_type __eval2(false_type) {return __eval(__uratio<__k/2, 0x8000000000000000ull>());}
     _LIBCPP_INLINE_VISIBILITY
     result_type __eval2(true_type) {return __evalf<__k, 0>();}
 
-    template <uint64_t _Np, uint64_t _Dp>
+    template <uint64_t _Np, uint64_t _Dp, __enable_if_t<(__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)), int> = 0>
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            (__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)),
-            result_type
-        >::type
         __eval(__uratio<_Np, _Dp>)
             {return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>();}
 
-    template <uint64_t _Np, uint64_t _Dp>
+    template <uint64_t _Np, uint64_t _Dp, __enable_if_t<__uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min), int> = 0>
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min),
-            result_type
-        >::type
         __eval(__uratio<_Np, _Dp>)
         {
             const size_t __j = static_cast<size_t>(__uratio<_Np, _Dp>::num * (__y_ - _Min)
                                                    / __uratio<_Np, _Dp>::den);
             __y_ = __v_[__j];
             __v_[__j] = __e_();
             return __y_;
         }

libcxx/include/__random/subtract_with_carry_engine.h

#endif
     template<class _Sseq>
         _LIBCPP_INLINE_VISIBILITY
         explicit subtract_with_carry_engine(_Sseq& __q,
         typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0)
         {seed(__q);}
     _LIBCPP_INLINE_VISIBILITY
     void seed(result_type __sd = default_seed)
         {seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
-    template<class _Sseq>
+    template<class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value, int> = 0>
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, subtract_with_carry_engine>::value,
-            void
-        >::type
         seed(_Sseq& __q)
             {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
 
     // generating functions
     _LIBCPP_HIDE_FROM_ABI result_type operator()();
     _LIBCPP_INLINE_VISIBILITY
     void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
 

libcxx/include/__system_error/error_code.h

error_code(_Ep __e, typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr) _NOEXCEPT {
     *this = make_error_code(__e);
   }
 
   _LIBCPP_HIDE_FROM_ABI void assign(int __val, const error_category& __cat) _NOEXCEPT {
     __val_ = __val;
     __cat_ = &__cat;
   }
 
-  template <class _Ep>
-  _LIBCPP_HIDE_FROM_ABI typename enable_if< is_error_code_enum<_Ep>::value, error_code& >::type
-  operator=(_Ep __e) _NOEXCEPT {
+  template <class _Ep, __enable_if_t<is_error_code_enum<_Ep>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI error_code& operator=(_Ep __e) _NOEXCEPT {
     using __adl_only::make_error_code;
     *this = make_error_code(__e);
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT {
     __val_ = 0;
     __cat_ = &system_category();

libcxx/include/__system_error/error_condition.h

error_condition(_Ep __e, typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr) _NOEXCEPT {
     *this = make_error_condition(__e);
   }
 
   _LIBCPP_HIDE_FROM_ABI void assign(int __val, const error_category& __cat) _NOEXCEPT {
     __val_ = __val;
     __cat_ = &__cat;
   }
 
-  template <class _Ep>
-  _LIBCPP_HIDE_FROM_ABI typename enable_if< is_error_condition_enum<_Ep>::value, error_condition& >::type
-  operator=(_Ep __e) _NOEXCEPT {
+  template <class _Ep, __enable_if_t<is_error_condition_enum<_Ep>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI error_condition& operator=(_Ep __e) _NOEXCEPT {
     using __adl_only::make_error_condition;
     *this = make_error_condition(__e);
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT {
     __val_ = 0;
     __cat_ = &generic_category();

libcxx/include/__type_traits/is_swappable.h

 template <class>
 using __swap_result_t = void;
 #endif
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __swap_result_t<_Tp> swap(_Tp& __x, _Tp& __y)
     _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value&& is_nothrow_move_assignable<_Tp>::value);
 
-template <class _Tp, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    typename enable_if<__is_swappable<_Tp>::value>::type swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np])
-        _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);
+template <class _Tp, size_t _Np, __enable_if_t<__is_swappable<_Tp>::value, int> = 0>
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np])
 
 namespace __detail {
 // ALL generic swap overloads MUST already have a declaration available at this point.
 
 template <class _Tp, class _Up = _Tp, bool _NotVoid = !is_void<_Tp>::value && !is_void<_Up>::value>
 struct __swappable_with {
   template <class _LHS, class _RHS>
   static decltype(swap(std::declval<_LHS>(), std::declval<_RHS>())) __test_swap(int);

libcxx/include/__utility/convert_to_integral.h

 unsigned long __convert_to_integral(unsigned long __val) { return __val; }
 
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 long long __convert_to_integral(long long __val) { return __val; }
 
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 unsigned long long __convert_to_integral(unsigned long long __val) {return __val; }
 
-template<typename _Fp>
+template<typename _Fp, __enable_if_t<is_floating_point<_Fp>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if<is_floating_point<_Fp>::value, long long>::type
+long long
  __convert_to_integral(_Fp __val) { return __val; }
 
 #ifndef _LIBCPP_HAS_NO_INT128
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 __int128_t __convert_to_integral(__int128_t __val) { return __val; }
 
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 __uint128_t __convert_to_integral(__uint128_t __val) { return __val; }

libcxx/include/__utility/pair.h

 
 template <class _T1, class _T2, class _U1, class _U2>
     requires requires { typename pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; }
 struct common_type<pair<_T1, _T2>, pair<_U1, _U2>> {
     using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>;
 };
 #endif // _LIBCPP_STD_VER >= 23
 
-template <class _T1, class _T2>
+template <class _T1, class _T2, __enable_if_t<__is_swappable<_T1>::value && __is_swappable<_T2>::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    __is_swappable<_T1>::value &&
-    __is_swappable<_T2>::value,
-    void
->::type
 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
                      _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
                                  __is_nothrow_swappable<_T2>::value))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 23

libcxx/include/__utility/swap.h

 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY __swap_result_t<_Tp> _LIBCPP_CONSTEXPR_SINCE_CXX20 swap(_Tp& __x, _Tp& __y)
     _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value&& is_nothrow_move_assignable<_Tp>::value) {
   _Tp __t(_VSTD::move(__x));
   __x = _VSTD::move(__y);
   __y = _VSTD::move(__t);
 }
 
-template <class _Tp, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 typename enable_if<__is_swappable<_Tp>::value>::type
-swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {
+template <class _Tp, size_t _Np, __enable_if_t<__is_swappable<_Tp>::value, int> >
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np])
+    _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {
   for (size_t __i = 0; __i != _Np; ++__i) {
     swap(__a[__i], __b[__i]);
   }
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___UTILITY_SWAP_H

libcxx/include/cmath

hypot(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
     typedef typename __promote<_A1, _A2, _A3>::type __result_type;
     static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value &&
                      is_same<_A3, __result_type>::value)), "");
     return std::hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
 }
 #endif
 
-template <class _A1>
+template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
 _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
+_LIBCPP_CONSTEXPR bool
 __constexpr_isnan(_A1 __lcpp_x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_isnan)
     return __builtin_isnan(__lcpp_x);
 #else
     return isnan(__lcpp_x);
 #endif
 }
 
-template <class _A1>
+template <class _A1, __enable_if_t<!is_floating_point<_A1>::value, int> = 0>
 _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
+_LIBCPP_CONSTEXPR bool
 __constexpr_isnan(_A1 __lcpp_x) _NOEXCEPT
 {
     return std::isnan(__lcpp_x);
 }
 
-template <class _A1>
+template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
 _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
+_LIBCPP_CONSTEXPR bool
 __constexpr_isinf(_A1 __lcpp_x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_isinf)
     return __builtin_isinf(__lcpp_x);
 #else
     return isinf(__lcpp_x);
 #endif
 }
 
-template <class _A1>
+template <class _A1, __enable_if_t<!is_floating_point<_A1>::value, int> = 0>
 _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
+_LIBCPP_CONSTEXPR bool
 __constexpr_isinf(_A1 __lcpp_x) _NOEXCEPT
 {
     return std::isinf(__lcpp_x);
 }
 
-template <class _A1>
+template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
 _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
+_LIBCPP_CONSTEXPR bool
 __constexpr_isfinite(_A1 __lcpp_x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_isfinite)
     return __builtin_isfinite(__lcpp_x);
 #else
     return isfinite(__lcpp_x);
 #endif
 }
 
-template <class _A1>
+template <class _A1, __enable_if_t<!is_floating_point<_A1>::value, int> = 0>
 _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
+_LIBCPP_CONSTEXPR bool
 __constexpr_isfinite(_A1 __lcpp_x) _NOEXCEPT
 {
     return __builtin_isfinite(__lcpp_x);
 }
 
 _LIBCPP_CONSTEXPR inline _LIBCPP_HIDE_FROM_ABI float __constexpr_copysign(float __x, float __y) _NOEXCEPT {
     return __builtin_copysignf(__x, __y);
 }

libcxx/include/complex

 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 arg(const complex<_Tp>& __c)
 {
     return std::atan2(__c.imag(), __c.real());
 }
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_same<_Tp, long double>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<
-    is_same<_Tp, long double>::value,
-    long double
->::type
 arg(_Tp __re)
 {
     return std::atan2l(0.L, __re);
 }
 
-template<class _Tp>
+template<class _Tp, __enable_if_t<is_integral<_Tp>::value || is_same<_Tp, double>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_integral<_Tp>::value || is_same<_Tp, double>::value,
-    double
->::type
 arg(_Tp __re)
 {
     return std::atan2(0., __re);
 }
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_same<_Tp, float>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<
-    is_same<_Tp, float>::value,
-    float
->::type
 arg(_Tp __re)
 {
     return std::atan2f(0.F, __re);
 }
 
 // norm
 
 template<class _Tp>

 proj(const complex<_Tp>& __c)
 {
     complex<_Tp> __r = __c;
     if (std::__constexpr_isinf(__c.real()) || std::__constexpr_isinf(__c.imag()))
         __r = complex<_Tp>(INFINITY, std::copysign(_Tp(0), __c.imag()));
     return __r;
 }
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_floating_point<_Tp>::value,
-    typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
->::type
 proj(_Tp __re)
 {
     if (std::__constexpr_isinf(__re))
         __re = std::abs(__re);
     return complex<_Tp>(__re);
 }
 
-template <class _Tp>
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_integral<_Tp>::value,
-    typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
->::type
 proj(_Tp __re)
 {
     typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
     return _ComplexType(__re);
 }
 
 // polar
 

 inline _LIBCPP_INLINE_VISIBILITY
 complex<typename __promote<_Tp, _Up>::type>
 pow(const complex<_Tp>& __x, const complex<_Up>& __y)
 {
     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
     return _VSTD::pow(result_type(__x), result_type(__y));
 }
 
-template<class _Tp, class _Up>
+template<class _Tp, class _Up, __enable_if_t<is_arithmetic<_Up>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_arithmetic<_Up>::value,
-    complex<typename __promote<_Tp, _Up>::type>
->::type
 pow(const complex<_Tp>& __x, const _Up& __y)
 {
     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
     return _VSTD::pow(result_type(__x), result_type(__y));
 }
 
-template<class _Tp, class _Up>
+template<class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_arithmetic<_Tp>::value,
-    complex<typename __promote<_Tp, _Up>::type>
->::type
 pow(const _Tp& __x, const complex<_Up>& __y)
 {
     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
     return _VSTD::pow(result_type(__x), result_type(__y));
 }
 
 // __sqr, computes pow(x, 2)
 

libcxx/include/ostream

 template<class _CharT, class _Traits, class _Yp>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p)
 {
     return __os << __p.get();
 }
 
-template<class _CharT, class _Traits, class _Yp, class _Dp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_same<void, __void_t<decltype((std::declval<basic_ostream<_CharT, _Traits>&>() << std::declval<typename unique_ptr<_Yp, _Dp>::pointer>()))> >::value,
-    basic_ostream<_CharT, _Traits>&
->::type
-operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p)
-{
+template <
+    class _CharT,
+    class _Traits,
+    class _Yp,
+    class _Dp,
+    __enable_if_t<is_same<void,
+                          __void_t<decltype((std::declval<basic_ostream<_CharT, _Traits>&>()
+                                             << std::declval<typename unique_ptr<_Yp, _Dp>::pointer>()))> >::value,
+                  int> = 0>
+inline _LIBCPP_INLINE_VISIBILITY basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p) {
     return __os << __p.get();
 }
 
 template <class _CharT, class _Traits, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
 {
     return __os << __x.template to_string<_CharT, _Traits>

libcxx/include/regex

#endif
     basic_regex& assign(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
         {return assign(__p, __p + __len, __f);}
     template <class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         basic_regex& assign(const basic_string<value_type, _ST, _SA>& __s,
                             flag_type __f = regex_constants::ECMAScript)
             {return assign(__s.begin(), __s.end(), __f);}
 
-    template <class _InputIterator>
+    template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if<__has_exactly_input_iterator_category<_InputIterator>::value, basic_regex&>::type
+        basic_regex&
         assign(_InputIterator __first, _InputIterator __last,
                             flag_type __f = regex_constants::ECMAScript)
         {
             basic_string<_CharT> __t(__first, __last);
             return assign(__t.begin(), __t.end(), __f);
         }
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     void __member_init(flag_type __f)
     {
         __flags_ = __f;
         __marked_count_ = 0;
         __loop_count_ = 0;
         __open_count_ = 0;
         __end_ = nullptr;
     }
 public:
 
-    template <class _ForwardIterator>
+    template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
         _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __has_forward_iterator_category<_ForwardIterator>::value,
-            basic_regex&
-        >::type
         assign(_ForwardIterator __first, _ForwardIterator __last,
                             flag_type __f = regex_constants::ECMAScript)
         {
             return assign(basic_regex(__first, __last, __f));
         }
 
 #ifndef _LIBCPP_CXX03_LANG
 

libcxx/include/set

#endif
     value_compare  value_comp()    const {return __tree_.value_comp();}
 
     // set operations:
     _LIBCPP_INLINE_VISIBILITY
     iterator find(const key_type& __k)             {return __tree_.find(__k);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    iterator
     find(const _K2& __k)                           {return __tree_.find(__k);}
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    const_iterator
     find(const _K2& __k) const                     {return __tree_.find(__k);}
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     size_type      count(const key_type& __k) const
         {return __tree_.__count_unique(__k);}
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
+    size_type
     count(const _K2& __k) const                    {return __tree_.__count_multi(__k);}
 #endif
 
 #if _LIBCPP_STD_VER >= 20
     _LIBCPP_INLINE_VISIBILITY
     bool contains(const key_type& __k) const {return find(__k) != end();}
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
+    bool
     contains(const _K2& __k) const { return find(__k) != end(); }
 #endif // _LIBCPP_STD_VER >= 20
 
     _LIBCPP_INLINE_VISIBILITY
     iterator lower_bound(const key_type& __k)
         {return __tree_.lower_bound(__k);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator lower_bound(const key_type& __k) const
         {return __tree_.lower_bound(__k);}
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    iterator
     lower_bound(const _K2& __k)       {return __tree_.lower_bound(__k);}
 
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    const_iterator
     lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     iterator upper_bound(const key_type& __k)
         {return __tree_.upper_bound(__k);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator upper_bound(const key_type& __k) const
         {return __tree_.upper_bound(__k);}
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    iterator
     upper_bound(const _K2& __k)       {return __tree_.upper_bound(__k);}
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    const_iterator
     upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     pair<iterator,iterator> equal_range(const key_type& __k)
         {return __tree_.__equal_range_unique(__k);}
     _LIBCPP_INLINE_VISIBILITY
     pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
         {return __tree_.__equal_range_unique(__k);}
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
+    pair<iterator,iterator>
     equal_range(const _K2& __k)       {return __tree_.__equal_range_multi(__k);}
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
+    pair<const_iterator,const_iterator>
     equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
 #endif
 };
 
 #if _LIBCPP_STD_VER >= 17
 template<class _InputIterator,
          class _Compare = less<__iter_value_type<_InputIterator>>,
          class _Allocator = allocator<__iter_value_type<_InputIterator>>,
#endif
     value_compare  value_comp()    const {return __tree_.value_comp();}
 
     // set operations:
     _LIBCPP_INLINE_VISIBILITY
     iterator find(const key_type& __k)             {return __tree_.find(__k);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    iterator
     find(const _K2& __k)                           {return __tree_.find(__k);}
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    const_iterator
     find(const _K2& __k) const                     {return __tree_.find(__k);}
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     size_type      count(const key_type& __k) const
         {return __tree_.__count_multi(__k);}
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
+    size_type
     count(const _K2& __k) const            {return __tree_.__count_multi(__k);}
 #endif
 
 #if _LIBCPP_STD_VER >= 20
     _LIBCPP_INLINE_VISIBILITY
     bool contains(const key_type& __k) const {return find(__k) != end();}
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
+     bool
     contains(const _K2& __k) const { return find(__k) != end(); }
 #endif // _LIBCPP_STD_VER >= 20
 
     _LIBCPP_INLINE_VISIBILITY
     iterator lower_bound(const key_type& __k)
         {return __tree_.lower_bound(__k);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator lower_bound(const key_type& __k) const
             {return __tree_.lower_bound(__k);}
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    iterator
     lower_bound(const _K2& __k)       {return __tree_.lower_bound(__k);}
 
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    const_iterator
     lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     iterator upper_bound(const key_type& __k)
             {return __tree_.upper_bound(__k);}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator upper_bound(const key_type& __k) const
             {return __tree_.upper_bound(__k);}
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
+    iterator
     upper_bound(const _K2& __k)       {return __tree_.upper_bound(__k);}
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
+    const_iterator
     upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     pair<iterator,iterator>             equal_range(const key_type& __k)
             {return __tree_.__equal_range_multi(__k);}
     _LIBCPP_INLINE_VISIBILITY
     pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
             {return __tree_.__equal_range_multi(__k);}
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
+    pair<iterator,iterator>
     equal_range(const _K2& __k)       {return __tree_.__equal_range_multi(__k);}
-    template <typename _K2>
+    template <typename _K2, enable_if_t<__is_transparent<_Compare, _K2>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
+    pair<const_iterator,const_iterator>
     equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
 #endif
 };
 
 #if _LIBCPP_STD_VER >= 17
 template<class _InputIterator,
          class _Compare = less<__iter_value_type<_InputIterator>>,
          class _Allocator = allocator<__iter_value_type<_InputIterator>>,

libcxx/include/valarray

#endif // _LIBCPP_CXX03_LANG
     valarray& operator&= (const value_type& __x);
     _LIBCPP_INLINE_VISIBILITY
     valarray& operator|= (const value_type& __x);
     _LIBCPP_INLINE_VISIBILITY
     valarray& operator<<=(const value_type& __x);
     _LIBCPP_INLINE_VISIBILITY
     valarray& operator>>=(const value_type& __x);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY valarray&
     operator*= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY valarray&
     operator/= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY valarray&
     operator%= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY valarray&
     operator+= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY valarray&
     operator-= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY valarray&
     operator^= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY valarray&
     operator|= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY valarray&
     operator&= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY valarray&
     operator<<= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    _LIBCPP_INLINE_VISIBILITY valarray&
     operator>>= (const _Expr& __v);
 
     // member functions:
     _LIBCPP_INLINE_VISIBILITY
     void swap(valarray& __v) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return static_cast<size_t>(__end_ - __begin_);}
public:
     typedef _Tp value_type;
 
 private:
     value_type* __vp_;
     size_t __size_;
     size_t __stride_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator*=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator/=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator%=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator+=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator-=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator^=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator&=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator|=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator<<=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
     slice_array(slice_array const&) = default;
 
     _LIBCPP_INLINE_VISIBILITY
     const slice_array& operator=(const slice_array& __sa) const;
 
slice_array<_Tp>::operator=(const slice_array& __sa) const
     value_type* __t = __vp_;
     const value_type* __s = __sa.__vp_;
     for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_)
         *__t = *__s;
     return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 slice_array<_Tp>::operator=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t = __v[__i];
 }
 
 template <class _Tp>
 inline void
 slice_array<_Tp>::operator=(const valarray<value_type>& __va) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __va.size(); ++__i, __t += __stride_)
         *__t = __va[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 slice_array<_Tp>::operator*=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t *= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 slice_array<_Tp>::operator/=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t /= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 slice_array<_Tp>::operator%=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t %= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 slice_array<_Tp>::operator+=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t += __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 slice_array<_Tp>::operator-=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t -= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 slice_array<_Tp>::operator^=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t ^= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 slice_array<_Tp>::operator&=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t &= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 slice_array<_Tp>::operator|=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t |= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 slice_array<_Tp>::operator<<=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t <<= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 slice_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
     for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
         *__t >>= __v[__i];
 }
 
 template <class _Tp>

 public:
     typedef _Tp value_type;
 
 private:
     value_type*      __vp_;
     valarray<size_t> __1d_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator*=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator/=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator%=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator+=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator-=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator^=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator&=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator|=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator<<=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
     _LIBCPP_INLINE_VISIBILITY
     const gslice_array& operator=(const gslice_array& __ga) const;
 
     _LIBCPP_INLINE_VISIBILITY
     void operator=(const value_type& __x) const;
gslice_array(gslice&& __gs, const valarray<value_type>& __v)
           __1d_(std::move(__gs.__1d_))
         {}
 #endif // _LIBCPP_CXX03_LANG
 
     template <class> friend class valarray;
 };
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 gslice_array<_Tp>::operator=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] = __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 gslice_array<_Tp>::operator*=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] *= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 gslice_array<_Tp>::operator/=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] /= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 gslice_array<_Tp>::operator%=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] %= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 gslice_array<_Tp>::operator+=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] += __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 gslice_array<_Tp>::operator-=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] -= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 gslice_array<_Tp>::operator^=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] ^= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 gslice_array<_Tp>::operator&=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] &= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 gslice_array<_Tp>::operator|=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] |= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 gslice_array<_Tp>::operator<<=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] <<= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 gslice_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
     size_t __j = 0;
     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
         __vp_[*__i] >>= __v[__j];
 }
 

 public:
     typedef _Tp value_type;
 
 private:
     value_type*      __vp_;
     valarray<size_t> __1d_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator*=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator/=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator%=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator+=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator-=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator^=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator&=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator|=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator<<=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
     mask_array(const mask_array&) = default;
 
     _LIBCPP_INLINE_VISIBILITY
     const mask_array& operator=(const mask_array& __ma) const;
 
mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
                   if (__vb[__i])
                       __1d_[__j++] = __i;
           }
 
     template <class> friend class valarray;
 };
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     void
->::type
 mask_array<_Tp>::operator=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] = __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     void
->::type
 mask_array<_Tp>::operator*=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] *= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     void
->::type
 mask_array<_Tp>::operator/=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] /= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     void
->::type
 mask_array<_Tp>::operator%=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] %= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     void
->::type
 mask_array<_Tp>::operator+=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] += __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     void
->::type
 mask_array<_Tp>::operator-=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] -= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     void
->::type
 mask_array<_Tp>::operator^=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] ^= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     void
->::type
 mask_array<_Tp>::operator&=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] &= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     void
->::type
 mask_array<_Tp>::operator|=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] |= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     void
->::type
 mask_array<_Tp>::operator<<=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] <<= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     void
->::type
 mask_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] >>= __v[__i];
 }
 
 template <class _Tp>

 public:
     typedef _Tp value_type;
 
 private:
     value_type*      __vp_;
     valarray<size_t> __1d_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator*=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator/=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator%=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator+=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator-=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator^=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator&=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator|=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator<<=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
     indirect_array(const indirect_array&) = default;
 
     _LIBCPP_INLINE_VISIBILITY
     const indirect_array& operator=(const indirect_array& __ia) const;
 
indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v)
         {}
 
 #endif // _LIBCPP_CXX03_LANG
 
     template <class> friend class valarray;
 };
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 indirect_array<_Tp>::operator=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] = __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 indirect_array<_Tp>::operator*=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] *= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 indirect_array<_Tp>::operator/=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] /= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 indirect_array<_Tp>::operator%=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] %= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 indirect_array<_Tp>::operator+=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] += __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 indirect_array<_Tp>::operator-=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] -= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 indirect_array<_Tp>::operator^=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] ^= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 indirect_array<_Tp>::operator&=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] &= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 indirect_array<_Tp>::operator|=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] |= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 indirect_array<_Tp>::operator<<=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] <<= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
 indirect_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
     for (size_t __i = 0; __i < __n; ++__i)
         __vp_[__1d_[__i]] >>= __v[__i];
 }
 
 template <class _Tp>

 valarray<_Tp>::operator>>=(const value_type& __x)
 {
     for (value_type* __p = __begin_; __p != __end_; ++__p)
         *__p >>= __x;
     return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     valarray<_Tp>&
->::type
 valarray<_Tp>::operator*=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t *= __v[__i];
     return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     valarray<_Tp>&
->::type
 valarray<_Tp>::operator/=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t /= __v[__i];
     return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     valarray<_Tp>&
->::type
 valarray<_Tp>::operator%=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t %= __v[__i];
     return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     valarray<_Tp>&
->::type
 valarray<_Tp>::operator+=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t += __v[__i];
     return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     valarray<_Tp>&
->::type
 valarray<_Tp>::operator-=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t -= __v[__i];
     return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     valarray<_Tp>&
->::type
 valarray<_Tp>::operator^=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t ^= __v[__i];
     return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     valarray<_Tp>&
->::type
 valarray<_Tp>::operator|=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t |= __v[__i];
     return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     valarray<_Tp>&
->::type
 valarray<_Tp>::operator&=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t &= __v[__i];
     return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     valarray<_Tp>&
->::type
 valarray<_Tp>::operator<<=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t <<= __v[__i];
     return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
 inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     valarray<_Tp>&
->::type
 valarray<_Tp>::operator>>=(const _Expr& __v)
 {
     size_t __i = 0;
     for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
         *__t >>= __v[__i];
     return *this;
 }
 

 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator*(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator*(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(multiplies<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator*(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(multiplies<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator/(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<divides<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator/(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(divides<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<divides<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator/(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(divides<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator%(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator%(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(modulus<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator%(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(modulus<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator+(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<plus<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator+(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(plus<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<plus<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator+(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(plus<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator-(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<minus<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator-(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(minus<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<minus<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator-(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(minus<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator^(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator^(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(bit_xor<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator^(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(bit_xor<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator&(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator&(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(bit_and<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator&(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(bit_and<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator|(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator|(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(bit_or<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator|(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(bit_or<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator<<(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator<<(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator<<(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator>>(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator>>(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator>>(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator&&(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator&&(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(logical_and<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator&&(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(logical_and<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator||(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator||(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(logical_or<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator||(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(logical_or<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator==(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator==(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(equal_to<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator==(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(equal_to<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator!=(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator!=(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(not_equal_to<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator!=(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(not_equal_to<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator<(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(less<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator<(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(less<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator<(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(less<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator>(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator>(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(greater<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator>(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(greater<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator<=(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator<=(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(less_equal<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator<=(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(less_equal<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 operator>=(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 operator>=(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(greater_equal<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 operator>=(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(greater_equal<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
->::type
 abs(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
->::type
 acos(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
->::type
 asin(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
->::type
 atan(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 atan2(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
                _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 atan2(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
                __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 atan2(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
->::type
 cos(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
->::type
 cosh(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
->::type
 exp(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
->::type
 log(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
->::type
 log10(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x));
 }
 
-template<class _Expr1, class _Expr2>
+template<class _Expr1, class _Expr2, __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
 pow(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
     typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op;
     return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
 pow(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
     return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
                            __x, __scalar_expr<value_type>(__y, __x.size())));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
 pow(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
     typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
                            __scalar_expr<value_type>(__x, __y.size()), __y));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
->::type
 sin(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
->::type
 sinh(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
->::type
 sqrt(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
->::type
 tan(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x));
 }
 
-template<class _Expr>
+template<class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
     __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
->::type
 tanh(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
     typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op;
     return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x));
 }
 
 template <class _Tp>

libcxx/include/vector

 #else
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
 #endif
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(vector&& __v, const __type_identity_t<allocator_type>& __a);
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
     vector& operator=(vector&& __v)
         _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
 
-    template <class _InputIterator>
-        typename enable_if <__has_exactly_input_iterator_category<_InputIterator>::value,
-           void
-        >::type
+    template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 assign(_InputIterator __first, _InputIterator __last);
-    template <class _ForwardIterator>
-        typename enable_if
-        <
-            __has_forward_iterator_category<_ForwardIterator>::value,
-           void
-        >::type
+    template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 assign(_ForwardIterator __first, _ForwardIterator __last);
 
 #if _LIBCPP_STD_VER >= 23
     template <_ContainerCompatibleRange<bool> _Range>
     _LIBCPP_HIDE_FROM_ABI
     constexpr void assign_range(_Range&& __range) {
       if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
         auto __n = static_cast<size_type>(ranges::distance(__range));

 #if _LIBCPP_STD_VER >= 14
     template <class... _Args>
    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator emplace(const_iterator __position, _Args&&... __args)
         { return insert ( __position, value_type ( std::forward<_Args>(__args)... )); }
 #endif
 
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __position, const value_type& __x);
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __position, size_type __n, const value_type& __x);
-    template <class _InputIterator>
-        typename enable_if <__has_exactly_input_iterator_category<_InputIterator>::value,
-            iterator
-        >::type
+    template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
         _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
-    template <class _ForwardIterator>
-        typename enable_if
-        <
-            __has_forward_iterator_category<_ForwardIterator>::value,
-            iterator
-        >::type
+    template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
         _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
 
 #if _LIBCPP_STD_VER >= 23
     template <_ContainerCompatibleRange<bool> _Range>
     _LIBCPP_HIDE_FROM_ABI
     constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
       if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
         auto __n = static_cast<size_type>(ranges::distance(__range));
if (__n > 0)
             __v.__size_ = __n;
             swap(__v);
         }
         std::fill_n(begin(), __n, __x);
     }
 }
 
 template <class _Allocator>
-template <class _InputIterator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 typename enable_if <__has_exactly_input_iterator_category<_InputIterator>::value,
-   void
->::type
+template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 {
   __assign_with_sentinel(__first, __last);
 }
 
 template <class _Allocator>
 template <class _Iterator, class _Sentinel>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
 void vector<bool, _Allocator>::__assign_with_sentinel(_Iterator __first, _Sentinel __last) {
     clear();
     for (; __first != __last; ++__first)
         push_back(*__first);
 }
 
 template <class _Allocator>
-template <class _ForwardIterator>
+template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    __has_forward_iterator_category<_ForwardIterator>::value,
-   void
->::type
 vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
   __assign_with_size(__first, __last, std::distance(__first, __last));
 }
 
 template <class _Allocator>
 template <class _ForwardIterator, class _Sentinel>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
else
         std::copy_backward(__position, cend(), __v.end());
         swap(__v);
     }
     std::fill_n(__r, __n, __x);
     return __r;
 }
 
 template <class _Allocator>
-template <class _InputIterator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 typename enable_if <__has_exactly_input_iterator_category<_InputIterator>::value,
-    typename vector<bool, _Allocator>::iterator
->::type
+template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
 {
   return __insert_with_sentinel(__position, __first, __last);
 }
 
 template <class _Allocator>
 template <class _InputIterator, class _Sentinel>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI

 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
     }
     __p = std::rotate(__p, __old_end, end());
     insert(__p, __v.begin(), __v.end());
     return begin() + __off;
 }
 
 template <class _Allocator>
-template <class _ForwardIterator>
+template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    __has_forward_iterator_category<_ForwardIterator>::value,
-    typename vector<bool, _Allocator>::iterator
->::type
 vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
 {
   return __insert_with_size(__position, __first, __last, std::distance(__first, __last));
 }
 
 template <class _Allocator>
 template <class _ForwardIterator, class _Sentinel>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI