diff --git a/libcxx/include/__algorithm/copy_n.h b/libcxx/include/__algorithm/copy_n.h
--- a/libcxx/include/__algorithm/copy_n.h
+++ b/libcxx/include/__algorithm/copy_n.h
@@ -21,14 +21,11 @@
 
 _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
+_OutputIterator
 copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
 {
     typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
@@ -47,13 +44,10 @@
     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
+_OutputIterator
 copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
 {
     typedef typename iterator_traits<_InputIterator>::difference_type difference_type;
diff --git a/libcxx/include/__algorithm/half_positive.h b/libcxx/include/__algorithm/half_positive.h
--- a/libcxx/include/__algorithm/half_positive.h
+++ b/libcxx/include/__algorithm/half_positive.h
@@ -22,25 +22,17 @@
 
 // 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
+_Integral
 __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
+_Tp
 __half_positive(_Tp __value)
 {
     return __value / 2;
diff --git a/libcxx/include/__atomic/atomic.h b/libcxx/include/__atomic/atomic.h
--- a/libcxx/include/__atomic/atomic.h
+++ b/libcxx/include/__atomic/atomic.h
@@ -505,25 +505,17 @@
 
 // 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
+_Tp
 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
+_Tp
 atomic_fetch_and(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_and(__op);
@@ -531,25 +523,17 @@
 
 // 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
+_Tp
 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
+_Tp
 atomic_fetch_and_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_and(__op, __m);
@@ -557,25 +541,17 @@
 
 // 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
+_Tp
 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
+_Tp
 atomic_fetch_or(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_or(__op);
@@ -583,25 +559,17 @@
 
 // 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
+_Tp
 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
+_Tp
 atomic_fetch_or_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_or(__op, __m);
@@ -609,25 +577,17 @@
 
 // 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
+_Tp
 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
+_Tp
 atomic_fetch_xor(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
 {
     return __o->fetch_xor(__op);
@@ -635,25 +595,17 @@
 
 // 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
+_Tp
 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
+_Tp
 atomic_fetch_xor_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
 {
     return __o->fetch_xor(__op, __m);
diff --git a/libcxx/include/__atomic/cxx_atomic_impl.h b/libcxx/include/__atomic/cxx_atomic_impl.h
--- a/libcxx/include/__atomic/cxx_atomic_impl.h
+++ b/libcxx/include/__atomic/cxx_atomic_impl.h
@@ -32,14 +32,12 @@
 // [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));
diff --git a/libcxx/include/__chrono/duration.h b/libcxx/include/__chrono/duration.h
--- a/libcxx/include/__chrono/duration.h
+++ b/libcxx/include/__chrono/duration.h
@@ -116,14 +116,10 @@
     }
 };
 
-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
+_ToDuration
 duration_cast(const duration<_Rep, _Period>& __fd)
 {
     return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
@@ -147,13 +143,9 @@
 };
 
 #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
+_ToDuration
 floor(const duration<_Rep, _Period>& __d)
 {
     _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
@@ -162,13 +154,9 @@
     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
+_ToDuration
 ceil(const duration<_Rep, _Period>& __d)
 {
     _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
@@ -177,13 +165,9 @@
     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
+_ToDuration
 round(const duration<_Rep, _Period>& __d)
 {
     _ToDuration __lower = chrono::floor<_ToDuration>(__d);
@@ -462,14 +446,11 @@
 
 // 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
+duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 {
     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
@@ -477,14 +458,11 @@
     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
+duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
 {
     return __d * __s;
@@ -492,15 +470,11 @@
 
 // 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
+duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 {
     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
@@ -520,15 +494,11 @@
 
 // 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
+duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 {
     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
diff --git a/libcxx/include/__chrono/time_point.h b/libcxx/include/__chrono/time_point.h
--- a/libcxx/include/__chrono/time_point.h
+++ b/libcxx/include/__chrono/time_point.h
@@ -93,49 +93,33 @@
 }
 
 #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
+time_point<_Clock, _ToDuration>
 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
+time_point<_Clock, _ToDuration>
 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
+time_point<_Clock, _ToDuration>
 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
+duration<_Rep, _Period>
 abs(duration<_Rep, _Period> __d)
 {
     return __d >= __d.zero() ? +__d : -__d;
diff --git a/libcxx/include/__filesystem/path.h b/libcxx/include/__filesystem/path.h
--- a/libcxx/include/__filesystem/path.h
+++ b/libcxx/include/__filesystem/path.h
@@ -76,9 +76,9 @@
   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('\\');
@@ -305,17 +305,17 @@
 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);
   }
@@ -350,17 +350,17 @@
       __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);
@@ -678,9 +678,9 @@
     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));
@@ -1040,21 +1040,19 @@
   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;
diff --git a/libcxx/include/__filesystem/u8path.h b/libcxx/include/__filesystem/u8path.h
--- a/libcxx/include/__filesystem/u8path.h
+++ b/libcxx/include/__filesystem/u8path.h
@@ -32,9 +32,9 @@
 
 _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
@@ -56,9 +56,9 @@
 }
 
 #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
@@ -79,9 +79,9 @@
 }
 #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
diff --git a/libcxx/include/__functional/bind.h b/libcxx/include/__functional/bind.h
--- a/libcxx/include/__functional/bind.h
+++ b/libcxx/include/__functional/bind.h
@@ -120,28 +120,20 @@
     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
+typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::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>
+template <class _Ti, class _Uj, __enable_if_t<!is_bind_expression<_Ti>::value &&
+                                              is_placeholder<_Ti>::value == 0 &&
+                                              !__is_reference_wrapper<_Ti>::value, int> = 0>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    !is_bind_expression<_Ti>::value &&
-    is_placeholder<_Ti>::value == 0 &&
-    !__is_reference_wrapper<_Ti>::value,
-    _Ti&
->::type
+_Ti&
 __mu(_Ti& __ti, _Uj&)
 {
     return __ti;
@@ -329,28 +321,20 @@
         : 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
+        result_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
+        result_type
         operator()(_Args&& ...__args) const
         {
             typedef __invoke_void_return_wrapper<_Rp> _Invoker;
diff --git a/libcxx/include/__iterator/next.h b/libcxx/include/__iterator/next.h
--- a/libcxx/include/__iterator/next.h
+++ b/libcxx/include/__iterator/next.h
@@ -24,9 +24,9 @@
 
 _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");
diff --git a/libcxx/include/__iterator/prev.h b/libcxx/include/__iterator/prev.h
--- a/libcxx/include/__iterator/prev.h
+++ b/libcxx/include/__iterator/prev.h
@@ -24,9 +24,9 @@
 
 _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");
diff --git a/libcxx/include/__memory/shared_ptr.h b/libcxx/include/__memory/shared_ptr.h
--- a/libcxx/include/__memory/shared_ptr.h
+++ b/libcxx/include/__memory/shared_ptr.h
@@ -1642,32 +1642,20 @@
 
     _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
+    template<class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+        weak_ptr&
         _LIBCPP_INLINE_VISIBILITY
         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
+    template<class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+        weak_ptr&
         _LIBCPP_INLINE_VISIBILITY
         operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT;
 
-    template<class _Yp>
-        typename enable_if
-        <
-            __compatible_with<_Yp, _Tp>::value,
-            weak_ptr&
-        >::type
+    template<class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+        weak_ptr&
         _LIBCPP_INLINE_VISIBILITY
         operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT;
 
@@ -1786,13 +1774,9 @@
 }
 
 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>&
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
@@ -1809,13 +1793,9 @@
 }
 
 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>&
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT
 {
     weak_ptr(_VSTD::move(__r)).swap(*this);
@@ -1823,13 +1803,9 @@
 }
 
 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>&
 weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
diff --git a/libcxx/include/__memory/unique_ptr.h b/libcxx/include/__memory/unique_ptr.h
--- a/libcxx/include/__memory/unique_ptr.h
+++ b/libcxx/include/__memory/unique_ptr.h
@@ -247,11 +247,10 @@
   }
 
 #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;
@@ -490,10 +489,9 @@
     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)
@@ -512,9 +510,9 @@
   }
 };
 
-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);
 }
diff --git a/libcxx/include/__random/discard_block_engine.h b/libcxx/include/__random/discard_block_engine.h
--- a/libcxx/include/__random/discard_block_engine.h
+++ b/libcxx/include/__random/discard_block_engine.h
@@ -82,13 +82,9 @@
     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
+        void
         seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;}
 
     // generating functions
diff --git a/libcxx/include/__random/independent_bits_engine.h b/libcxx/include/__random/independent_bits_engine.h
--- a/libcxx/include/__random/independent_bits_engine.h
+++ b/libcxx/include/__random/independent_bits_engine.h
@@ -114,13 +114,9 @@
     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
+        void
         seed(_Sseq& __q) {__e_.seed(__q);}
 
     // generating functions
@@ -166,24 +162,16 @@
     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
+        result_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
+        result_type
         __lshift(result_type) {return result_type(0);}
 };
 
diff --git a/libcxx/include/__random/linear_congruential_engine.h b/libcxx/include/__random/linear_congruential_engine.h
--- a/libcxx/include/__random/linear_congruential_engine.h
+++ b/libcxx/include/__random/linear_congruential_engine.h
@@ -255,13 +255,9 @@
     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
+        void
         seed(_Sseq& __q)
             {__seed(__q, integral_constant<unsigned,
                 1 + (__m == 0 ? (sizeof(result_type) * __CHAR_BIT__ - 1)/32
diff --git a/libcxx/include/__random/mersenne_twister_engine.h b/libcxx/include/__random/mersenne_twister_engine.h
--- a/libcxx/include/__random/mersenne_twister_engine.h
+++ b/libcxx/include/__random/mersenne_twister_engine.h
@@ -141,13 +141,9 @@
         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
+        void
         seed(_Sseq& __q)
             {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
 
@@ -202,44 +198,28 @@
     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
+        result_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
+        result_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
+        result_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
+        result_type
         __rshift(result_type) {return result_type(0);}
 };
 
diff --git a/libcxx/include/__random/shuffle_order_engine.h b/libcxx/include/__random/shuffle_order_engine.h
--- a/libcxx/include/__random/shuffle_order_engine.h
+++ b/libcxx/include/__random/shuffle_order_engine.h
@@ -108,13 +108,9 @@
     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
+        void
         seed(_Sseq& __q) {__e_.seed(__q); __init();}
 
     // generating functions
@@ -174,23 +170,15 @@
     _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
+        result_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
+        result_type
         __eval(__uratio<_Np, _Dp>)
         {
             const size_t __j = static_cast<size_t>(__uratio<_Np, _Dp>::num * (__y_ - _Min)
diff --git a/libcxx/include/__random/subtract_with_carry_engine.h b/libcxx/include/__random/subtract_with_carry_engine.h
--- a/libcxx/include/__random/subtract_with_carry_engine.h
+++ b/libcxx/include/__random/subtract_with_carry_engine.h
@@ -109,13 +109,9 @@
     _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
+        void
         seed(_Sseq& __q)
             {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
 
diff --git a/libcxx/include/__system_error/error_code.h b/libcxx/include/__system_error/error_code.h
--- a/libcxx/include/__system_error/error_code.h
+++ b/libcxx/include/__system_error/error_code.h
@@ -61,9 +61,8 @@
     __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;
diff --git a/libcxx/include/__system_error/error_condition.h b/libcxx/include/__system_error/error_condition.h
--- a/libcxx/include/__system_error/error_condition.h
+++ b/libcxx/include/__system_error/error_condition.h
@@ -70,9 +70,8 @@
     __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;
diff --git a/libcxx/include/__type_traits/is_swappable.h b/libcxx/include/__type_traits/is_swappable.h
--- a/libcxx/include/__type_traits/is_swappable.h
+++ b/libcxx/include/__type_traits/is_swappable.h
@@ -47,10 +47,9 @@
 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])
+    _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);
 
 namespace __detail {
 // ALL generic swap overloads MUST already have a declaration available at this point.
diff --git a/libcxx/include/__utility/convert_to_integral.h b/libcxx/include/__utility/convert_to_integral.h
--- a/libcxx/include/__utility/convert_to_integral.h
+++ b/libcxx/include/__utility/convert_to_integral.h
@@ -39,9 +39,9 @@
 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
diff --git a/libcxx/include/__utility/pair.h b/libcxx/include/__utility/pair.h
--- a/libcxx/include/__utility/pair.h
+++ b/libcxx/include/__utility/pair.h
@@ -688,14 +688,9 @@
 };
 #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
+void
 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
                      _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
                                  __is_nothrow_swappable<_T2>::value))
diff --git a/libcxx/include/__utility/swap.h b/libcxx/include/__utility/swap.h
--- a/libcxx/include/__utility/swap.h
+++ b/libcxx/include/__utility/swap.h
@@ -44,9 +44,9 @@
   __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]);
   }
diff --git a/libcxx/include/cmath b/libcxx/include/cmath
--- a/libcxx/include/cmath
+++ b/libcxx/include/cmath
@@ -569,9 +569,9 @@
 }
 #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)
@@ -581,17 +581,17 @@
 #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)
@@ -601,17 +601,17 @@
 #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)
@@ -621,9 +621,9 @@
 #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);
diff --git a/libcxx/include/complex b/libcxx/include/complex
--- a/libcxx/include/complex
+++ b/libcxx/include/complex
@@ -942,35 +942,25 @@
     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
+long double
 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
+double
 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
+float
 arg(_Tp __re)
 {
     return std::atan2f(0.F, __re);
@@ -1033,13 +1023,9 @@
     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
+typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
 proj(_Tp __re)
 {
     if (std::__constexpr_isinf(__re))
@@ -1047,13 +1033,9 @@
     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
+typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
 proj(_Tp __re)
 {
     typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
@@ -1173,26 +1155,18 @@
     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
+complex<typename __promote<_Tp, _Up>::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
+complex<typename __promote<_Tp, _Up>::type>
 pow(const _Tp& __x, const complex<_Up>& __y)
 {
     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
diff --git a/libcxx/include/ostream b/libcxx/include/ostream
--- a/libcxx/include/ostream
+++ b/libcxx/include/ostream
@@ -1117,15 +1117,17 @@
     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();
 }
 
diff --git a/libcxx/include/regex b/libcxx/include/regex
--- a/libcxx/include/regex
+++ b/libcxx/include/regex
@@ -2776,9 +2776,9 @@
                             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)
         {
@@ -2798,13 +2798,9 @@
     }
 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
+        basic_regex&
         assign(_ForwardIterator __first, _ForwardIterator __last,
                             flag_type __f = regex_constants::ECMAScript)
         {
diff --git a/libcxx/include/set b/libcxx/include/set
--- a/libcxx/include/set
+++ b/libcxx/include/set
@@ -920,13 +920,13 @@
     _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
 
@@ -934,18 +934,18 @@
     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
 
@@ -956,14 +956,14 @@
     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
 
@@ -974,13 +974,13 @@
     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
 
@@ -991,13 +991,13 @@
     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
 };
@@ -1511,13 +1511,13 @@
     _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
 
@@ -1525,18 +1525,18 @@
     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
 
@@ -1547,14 +1547,14 @@
     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
 
@@ -1565,13 +1565,13 @@
     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
 
@@ -1582,13 +1582,13 @@
     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
 };
diff --git a/libcxx/include/valarray b/libcxx/include/valarray
--- a/libcxx/include/valarray
+++ b/libcxx/include/valarray
@@ -971,93 +971,53 @@
     _LIBCPP_INLINE_VISIBILITY
     valarray& operator>>=(const value_type& __x);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    valarray&
     _LIBCPP_INLINE_VISIBILITY
     operator*= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    valarray&
     _LIBCPP_INLINE_VISIBILITY
     operator/= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    valarray&
     _LIBCPP_INLINE_VISIBILITY
     operator%= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    valarray&
     _LIBCPP_INLINE_VISIBILITY
     operator+= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    valarray&
     _LIBCPP_INLINE_VISIBILITY
     operator-= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    valarray&
     _LIBCPP_INLINE_VISIBILITY
     operator^= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    valarray&
     _LIBCPP_INLINE_VISIBILITY
     operator|= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    valarray&
     _LIBCPP_INLINE_VISIBILITY
     operator&= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    valarray&
     _LIBCPP_INLINE_VISIBILITY
     operator<<= (const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
+    template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+    valarray&
     _LIBCPP_INLINE_VISIBILITY
     operator>>= (const _Expr& __v);
 
@@ -1219,102 +1179,58 @@
     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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
@@ -1353,13 +1269,9 @@
 }
 
 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
+void
 slice_array<_Tp>::operator=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
@@ -1377,13 +1289,9 @@
 }
 
 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
+void
 slice_array<_Tp>::operator*=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
@@ -1392,13 +1300,9 @@
 }
 
 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
+void
 slice_array<_Tp>::operator/=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
@@ -1407,13 +1311,9 @@
 }
 
 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
+void
 slice_array<_Tp>::operator%=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
@@ -1422,13 +1322,9 @@
 }
 
 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
+void
 slice_array<_Tp>::operator+=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
@@ -1437,13 +1333,9 @@
 }
 
 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
+void
 slice_array<_Tp>::operator-=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
@@ -1452,13 +1344,9 @@
 }
 
 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
+void
 slice_array<_Tp>::operator^=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
@@ -1467,13 +1355,9 @@
 }
 
 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
+void
 slice_array<_Tp>::operator&=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
@@ -1482,13 +1366,9 @@
 }
 
 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
+void
 slice_array<_Tp>::operator|=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
@@ -1497,13 +1377,9 @@
 }
 
 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
+void
 slice_array<_Tp>::operator<<=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
@@ -1512,13 +1388,9 @@
 }
 
 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
+void
 slice_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     value_type* __t = __vp_;
@@ -1610,102 +1482,58 @@
     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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
@@ -1734,13 +1562,9 @@
 };
 
 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
+void
 gslice_array<_Tp>::operator=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
@@ -1750,13 +1574,9 @@
 }
 
 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
+void
 gslice_array<_Tp>::operator*=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
@@ -1766,13 +1586,9 @@
 }
 
 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
+void
 gslice_array<_Tp>::operator/=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
@@ -1782,13 +1598,9 @@
 }
 
 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
+void
 gslice_array<_Tp>::operator%=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
@@ -1798,13 +1610,9 @@
 }
 
 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
+void
 gslice_array<_Tp>::operator+=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
@@ -1814,13 +1622,9 @@
 }
 
 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
+void
 gslice_array<_Tp>::operator-=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
@@ -1830,13 +1634,9 @@
 }
 
 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
+void
 gslice_array<_Tp>::operator^=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
@@ -1846,13 +1646,9 @@
 }
 
 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
+void
 gslice_array<_Tp>::operator&=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
@@ -1862,13 +1658,9 @@
 }
 
 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
+void
 gslice_array<_Tp>::operator|=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
@@ -1878,13 +1670,9 @@
 }
 
 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
+void
 gslice_array<_Tp>::operator<<=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
@@ -1894,13 +1682,9 @@
 }
 
 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
+void
 gslice_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     typedef const size_t* _Ip;
@@ -1945,102 +1729,58 @@
     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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
@@ -2068,13 +1808,9 @@
 };
 
 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();
@@ -2083,13 +1819,9 @@
 }
 
 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();
@@ -2098,13 +1830,9 @@
 }
 
 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();
@@ -2113,13 +1841,9 @@
 }
 
 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();
@@ -2128,13 +1852,9 @@
 }
 
 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();
@@ -2143,13 +1863,9 @@
 }
 
 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();
@@ -2158,13 +1874,9 @@
 }
 
 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();
@@ -2173,13 +1885,9 @@
 }
 
 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();
@@ -2188,13 +1896,9 @@
 }
 
 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();
@@ -2203,13 +1907,9 @@
 }
 
 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();
@@ -2218,13 +1918,9 @@
 }
 
 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();
@@ -2301,102 +1997,58 @@
     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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _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>
+    void
     _LIBCPP_INLINE_VISIBILITY
     operator>>=(const _Expr& __v) const;
 
@@ -2429,13 +2081,9 @@
 };
 
 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
+void
 indirect_array<_Tp>::operator=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
@@ -2444,13 +2092,9 @@
 }
 
 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
+void
 indirect_array<_Tp>::operator*=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
@@ -2459,13 +2103,9 @@
 }
 
 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
+void
 indirect_array<_Tp>::operator/=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
@@ -2474,13 +2114,9 @@
 }
 
 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
+void
 indirect_array<_Tp>::operator%=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
@@ -2489,13 +2125,9 @@
 }
 
 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
+void
 indirect_array<_Tp>::operator+=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
@@ -2504,13 +2136,9 @@
 }
 
 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
+void
 indirect_array<_Tp>::operator-=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
@@ -2519,13 +2147,9 @@
 }
 
 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
+void
 indirect_array<_Tp>::operator^=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
@@ -2534,13 +2158,9 @@
 }
 
 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
+void
 indirect_array<_Tp>::operator&=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
@@ -2549,13 +2169,9 @@
 }
 
 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
+void
 indirect_array<_Tp>::operator|=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
@@ -2564,13 +2180,9 @@
 }
 
 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
+void
 indirect_array<_Tp>::operator<<=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
@@ -2579,13 +2191,9 @@
 }
 
 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
+void
 indirect_array<_Tp>::operator>>=(const _Expr& __v) const
 {
     size_t __n = __1d_.size();
@@ -3456,13 +3064,9 @@
 }
 
 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;
@@ -3472,13 +3076,9 @@
 }
 
 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;
@@ -3488,13 +3088,9 @@
 }
 
 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;
@@ -3504,13 +3100,9 @@
 }
 
 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;
@@ -3520,13 +3112,9 @@
 }
 
 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;
@@ -3536,13 +3124,9 @@
 }
 
 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;
@@ -3552,13 +3136,9 @@
 }
 
 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;
@@ -3568,13 +3148,9 @@
 }
 
 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;
@@ -3584,13 +3160,9 @@
 }
 
 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;
@@ -3600,13 +3172,9 @@
 }
 
 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;
@@ -3789,13 +3357,9 @@
     __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
+__val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator*(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -3803,14 +3367,10 @@
     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
+__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator*(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -3819,14 +3379,10 @@
                            __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
+__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator*(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -3835,13 +3391,9 @@
                            __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
+__val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator/(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -3849,14 +3401,10 @@
     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
+__val_expr<_BinaryOp<divides<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator/(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -3865,14 +3413,10 @@
                            __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
+__val_expr<_BinaryOp<divides<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator/(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -3881,13 +3425,9 @@
                            __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
+__val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator%(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -3895,14 +3435,10 @@
     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
+__val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator%(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -3911,14 +3447,10 @@
                            __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
+__val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator%(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -3927,13 +3459,9 @@
                            __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
+__val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator+(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -3941,14 +3469,10 @@
     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
+__val_expr<_BinaryOp<plus<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator+(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -3957,14 +3481,10 @@
                            __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
+__val_expr<_BinaryOp<plus<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator+(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -3973,13 +3493,9 @@
                            __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
+__val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator-(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -3987,14 +3503,10 @@
     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
+__val_expr<_BinaryOp<minus<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator-(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4003,14 +3515,10 @@
                            __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
+__val_expr<_BinaryOp<minus<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator-(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4019,13 +3527,9 @@
                            __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
+__val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator^(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4033,14 +3537,10 @@
     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
+__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator^(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4049,14 +3549,10 @@
                            __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
+__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator^(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4065,13 +3561,9 @@
                            __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
+__val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator&(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4079,14 +3571,10 @@
     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
+__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator&(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4095,14 +3583,10 @@
                            __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
+__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator&(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4111,13 +3595,9 @@
                            __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
+__val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator|(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4125,14 +3605,10 @@
     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
+__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator|(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4141,14 +3617,10 @@
                            __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
+__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator|(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4157,13 +3629,9 @@
                            __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
+__val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator<<(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4171,14 +3639,10 @@
     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
+__val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator<<(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4187,14 +3651,10 @@
                            __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
+__val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator<<(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4203,13 +3663,9 @@
                            __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
+__val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator>>(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4217,14 +3673,10 @@
     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
+__val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator>>(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4233,14 +3685,10 @@
                            __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
+__val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator>>(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4249,13 +3697,9 @@
                            __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
+__val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator&&(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4263,14 +3707,10 @@
     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
+__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator&&(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4279,14 +3719,10 @@
                            __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
+__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator&&(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4295,13 +3731,9 @@
                            __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
+__val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator||(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4309,14 +3741,10 @@
     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
+__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator||(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4325,14 +3753,10 @@
                            __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
+__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator||(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4341,13 +3765,9 @@
                            __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
+__val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator==(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4355,14 +3775,10 @@
     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
+__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator==(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4371,14 +3787,10 @@
                            __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
+__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator==(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4387,13 +3799,9 @@
                            __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
+__val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator!=(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4401,14 +3809,10 @@
     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
+__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator!=(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4417,14 +3821,10 @@
                            __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
+__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator!=(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4433,13 +3833,9 @@
                            __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
+__val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator<(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4447,14 +3843,10 @@
     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
+__val_expr<_BinaryOp<less<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator<(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4463,14 +3855,10 @@
                            __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
+__val_expr<_BinaryOp<less<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator<(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4479,13 +3867,9 @@
                            __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
+__val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator>(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4493,14 +3877,10 @@
     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
+__val_expr<_BinaryOp<greater<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator>(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4509,14 +3889,10 @@
                            __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
+__val_expr<_BinaryOp<greater<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator>(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4525,13 +3901,9 @@
                            __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
+__val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator<=(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4539,14 +3911,10 @@
     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
+__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator<=(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4555,14 +3923,10 @@
                            __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
+__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator<=(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4571,13 +3935,9 @@
                            __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
+__val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
 operator>=(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4585,14 +3945,10 @@
     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
+__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 operator>=(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4601,14 +3957,10 @@
                            __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
+__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 operator>=(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4617,13 +3969,9 @@
                            __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
+__val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
 abs(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
@@ -4631,13 +3979,9 @@
     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
+__val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
 acos(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
@@ -4645,13 +3989,9 @@
     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
+__val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
 asin(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
@@ -4659,13 +3999,9 @@
     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
+__val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
 atan(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
@@ -4673,13 +4009,9 @@
     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
+__val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
 atan2(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4687,14 +4019,10 @@
     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;
@@ -4703,14 +4031,10 @@
                            __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;
@@ -4719,13 +4043,9 @@
                            __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
+__val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
 cos(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
@@ -4733,13 +4053,9 @@
     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
+__val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
 cosh(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
@@ -4747,13 +4063,9 @@
     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
+__val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
 exp(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
@@ -4761,13 +4073,9 @@
     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
+__val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
 log(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
@@ -4775,13 +4083,9 @@
     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
+__val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
 log10(const _Expr& __x)
 {
     typedef typename _Expr::value_type value_type;
@@ -4789,13 +4093,9 @@
     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
+__val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
 pow(const _Expr1& __x, const _Expr2& __y)
 {
     typedef typename _Expr1::value_type value_type;
@@ -4803,14 +4103,10 @@
     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
+__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
+           _Expr, __scalar_expr<typename _Expr::value_type> > >
 pow(const _Expr& __x, const typename _Expr::value_type& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4819,14 +4115,10 @@
                            __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
+__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
+           __scalar_expr<typename _Expr::value_type>, _Expr> >
 pow(const typename _Expr::value_type& __x, const _Expr& __y)
 {
     typedef typename _Expr::value_type value_type;
@@ -4835,13 +4127,9 @@
                            __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;
@@ -4849,13 +4137,9 @@
     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;
@@ -4863,13 +4147,9 @@
     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;
@@ -4877,13 +4157,9 @@
     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;
@@ -4891,13 +4167,9 @@
     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;
diff --git a/libcxx/include/vector b/libcxx/include/vector
--- a/libcxx/include/vector
+++ b/libcxx/include/vector
@@ -2198,17 +2198,11 @@
     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>
+    void
     _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>
+    void
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 assign(_ForwardIterator __first, _ForwardIterator __last);
 
 #if _LIBCPP_STD_VER >= 23
@@ -2332,17 +2326,11 @@
 
     _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>
+        iterator
         _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>
+        iterator
         _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
 
 #if _LIBCPP_STD_VER >= 23
@@ -2924,10 +2912,9 @@
 }
 
 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
+void
 vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
 {
   __assign_with_sentinel(__first, __last);
@@ -2943,13 +2930,9 @@
 }
 
 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
+void
 vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
   __assign_with_size(__first, __last, std::distance(__first, __last));
@@ -3090,10 +3073,9 @@
 }
 
 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
+typename vector<bool, _Allocator>::iterator
 vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
 {
   return __insert_with_sentinel(__position, __first, __last);
@@ -3140,13 +3122,9 @@
 }
 
 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
+typename vector<bool, _Allocator>::iterator
 vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
 {
   return __insert_with_size(__position, __first, __last, std::distance(__first, __last));