diff --git a/libcxx/benchmarks/CMakeLists.txt b/libcxx/benchmarks/CMakeLists.txt
--- a/libcxx/benchmarks/CMakeLists.txt
+++ b/libcxx/benchmarks/CMakeLists.txt
@@ -108,6 +108,7 @@
 target_link_libraries( cxx-benchmarks-flags-libcxx INTERFACE cxx-benchmarks-flags)
 target_compile_options(cxx-benchmarks-flags-libcxx INTERFACE ${SANITIZER_FLAGS} -Wno-user-defined-literals -Wno-suggest-override)
 target_link_options(   cxx-benchmarks-flags-libcxx INTERFACE -nodefaultlibs "-L${BENCHMARK_LIBCXX_INSTALL}/lib" ${SANITIZER_FLAGS})
+target_link_options(   cxx-benchmarks-flags-libcxx INTERFACE -nodefaultlibs "-L${BENCHMARK_LIBCXX_INSTALL}/lib64" ${SANITIZER_FLAGS})
 
 set(libcxx_benchmark_targets)
 
@@ -158,6 +159,7 @@
 #==============================================================================
 set(BENCHMARK_TESTS
     algorithms.partition_point.bench.cpp
+    algorithms/equal.bench.cpp
     algorithms/lower_bound.bench.cpp
     algorithms/make_heap.bench.cpp
     algorithms/make_heap_then_sort_heap.bench.cpp
diff --git a/libcxx/benchmarks/algorithms/equal.bench.cpp b/libcxx/benchmarks/algorithms/equal.bench.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/benchmarks/algorithms/equal.bench.cpp
@@ -0,0 +1,38 @@
+#include <algorithm>
+#include <benchmark/benchmark.h>
+#include <cstring>
+
+static void bm_equal_iter(benchmark::State& state) {
+  std::vector<char> vec1(state.range(), '1');
+  std::vector<char> vec2(state.range(), '1');
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(vec1);
+    benchmark::DoNotOptimize(vec2);
+    benchmark::DoNotOptimize(std::equal(vec1.begin(), vec1.end(), vec2.begin()));
+  }
+}
+BENCHMARK(bm_equal_iter)->DenseRange(1, 8)->Range(16, 1 << 20);
+
+static void bm_equal(benchmark::State& state) {
+  std::vector<char> vec1(state.range(), '1');
+  std::vector<char> vec2(state.range(), '1');
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(vec1);
+    benchmark::DoNotOptimize(vec2);
+    benchmark::DoNotOptimize(std::equal(vec1.begin(), vec1.end(), vec2.begin(), vec2.end()));
+  }
+}
+BENCHMARK(bm_equal)->DenseRange(1, 8)->Range(16, 1 << 20);
+
+static void bm_ranges_equal(benchmark::State& state) {
+  std::vector<char> vec1(state.range(), '1');
+  std::vector<char> vec2(state.range(), '1');
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(vec1);
+    benchmark::DoNotOptimize(vec2);
+    benchmark::DoNotOptimize(std::ranges::equal(vec1, vec2));
+  }
+}
+BENCHMARK(bm_ranges_equal)->DenseRange(1, 8)->Range(16, 1 << 20);
+
+BENCHMARK_MAIN();
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -580,6 +580,7 @@
   __type_traits/is_callable.h
   __type_traits/is_char_like_type.h
   __type_traits/is_class.h
+  __type_traits/is_comparable.h
   __type_traits/is_compound.h
   __type_traits/is_const.h
   __type_traits/is_constant_evaluated.h
@@ -618,6 +619,7 @@
   __type_traits/is_pod.h
   __type_traits/is_pointer.h
   __type_traits/is_polymorphic.h
+  __type_traits/is_predicate_kind.h
   __type_traits/is_primary_template.h
   __type_traits/is_reference.h
   __type_traits/is_reference_wrapper.h
diff --git a/libcxx/include/__algorithm/comp.h b/libcxx/include/__algorithm/comp.h
--- a/libcxx/include/__algorithm/comp.h
+++ b/libcxx/include/__algorithm/comp.h
@@ -10,6 +10,8 @@
 #define _LIBCPP___ALGORITHM_COMP_H
 
 #include <__config>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_predicate_kind.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -24,6 +26,9 @@
   }
 };
 
+template <>
+struct __is_equal_to_predicate<__equal_to> : true_type {};
+
 template <class _T1, class _T2 = _T1>
 struct __less
 {
diff --git a/libcxx/include/__algorithm/equal.h b/libcxx/include/__algorithm/equal.h
--- a/libcxx/include/__algorithm/equal.h
+++ b/libcxx/include/__algorithm/equal.h
@@ -11,9 +11,19 @@
 #define _LIBCPP___ALGORITHM_EQUAL_H
 
 #include <__algorithm/comp.h>
+#include <__algorithm/unwrap_iter.h>
 #include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_comparable.h>
+#include <__type_traits/is_constant_evaluated.h>
+#include <__type_traits/is_predicate_kind.h>
+#include <__type_traits/is_volatile.h>
+#include <cstring>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -22,14 +32,40 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) {
+_LIBCPP_NODISCARD inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_iter_trivial_impl(
+    _InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) {
   for (; __first1 != __last1; ++__first1, (void)++__first2)
     if (!__pred(*__first1, *__first2))
       return false;
   return true;
 }
 
+template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
+_LIBCPP_NODISCARD inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_iter_impl(
+    _InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) {
+  return std::__equal_iter_trivial_impl(__first1, __last1, __first2, __pred);
+}
+
+template <class _Tp,
+          class _Up,
+          class _BinaryPredicate,
+          __enable_if_t<__is_equal_to_predicate<_BinaryPredicate>::value && !is_volatile<_Tp>::value &&
+                            !is_volatile<_Up>::value && __is_trivially_equality_comparable<_Tp, _Up>::value,
+                        int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+__equal_iter_impl(_Tp* __first1, _Tp* __last1, _Up* __first2, _BinaryPredicate __pred) {
+  if (!__libcpp_is_constant_evaluated() || sizeof(_Tp) == 1)
+    return std::__constexpr_memcmp(__first1, __first2, (__last1 - __first1) * sizeof(_Tp)) == 0;
+  return std::__equal_iter_trivial_impl(__first1, __last1, __first2, __pred);
+}
+
+template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
+_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) {
+  return std::__equal_iter_impl(
+      std::__unwrap_iter(__first1), std::__unwrap_iter(__last1), std::__unwrap_iter(__first2), __pred);
+}
+
 template <class _InputIterator1, class _InputIterator2>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) {
@@ -47,6 +83,40 @@
   return __first1 == __last1 && __first2 == __last2;
 }
 
+template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_trivial_impl(
+    _Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred& __comp, _Proj1& __proj1, _Proj2& __proj2) {
+  while (__first1 != __last1 && __first2 != __last2) {
+    if (!std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
+      return false;
+    ++__first1;
+    ++__first2;
+  }
+  return __first1 == __last1 && __first2 == __last2;
+}
+
+template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_impl(
+    _Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred& __comp, _Proj1& __proj1, _Proj2& __proj2) {
+  return std::__equal_trivial_impl(__first1, __last1, __first2, __last2, __comp, __proj1, __proj2);
+}
+
+template <class _Tp,
+          class _Up,
+          class _Pred,
+          class _Proj1,
+          class _Proj2,
+          __enable_if_t<__is_equal_to_predicate<_Pred>::value && __is_identity<_Proj1>::value &&
+                            __is_identity<_Proj2>::value && !is_volatile<_Tp>::value && !is_volatile<_Up>::value &&
+                            __is_trivially_equality_comparable<_Tp, _Up>::value,
+                        int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_impl(
+    _Tp* __first1, _Tp* __last1, _Up* __first2, _Up* __last2, _Pred& __comp, _Proj1& __proj1, _Proj2& __proj2) {
+  if (!__libcpp_is_constant_evaluated() || sizeof(_Tp) == 1)
+    return std::__constexpr_memcmp(__first1, __first2, (__last1 - __first1) * sizeof(_Tp)) == 0;
+  return std::__equal_trivial_impl(__first1, __last1, __first2, __last2, __comp, __proj1, __proj2);
+}
+
 template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 __equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2,
@@ -54,8 +124,15 @@
         random_access_iterator_tag) {
   if (_VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2))
     return false;
-  return _VSTD::equal<_RandomAccessIterator1, _RandomAccessIterator2,
-                      _BinaryPredicate&>(__first1, __last1, __first2, __pred);
+  __identity __proj;
+  return std::__equal_impl(
+      std::__unwrap_iter(__first1),
+      std::__unwrap_iter(__last1),
+      std::__unwrap_iter(__first2),
+      std::__unwrap_iter(__last2),
+      __pred,
+      __proj,
+      __proj);
 }
 
 template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
diff --git a/libcxx/include/__algorithm/ranges_equal.h b/libcxx/include/__algorithm/ranges_equal.h
--- a/libcxx/include/__algorithm/ranges_equal.h
+++ b/libcxx/include/__algorithm/ranges_equal.h
@@ -9,6 +9,8 @@
 #ifndef _LIBCPP___ALGORITHM_RANGES_EQUAL_H
 #define _LIBCPP___ALGORITHM_RANGES_EQUAL_H
 
+#include <__algorithm/equal.h>
+#include <__algorithm/unwrap_range.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
@@ -19,6 +21,7 @@
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -31,29 +34,6 @@
 namespace ranges {
 namespace __equal {
 struct __fn {
-private:
-  template <class _Iter1, class _Sent1,
-            class _Iter2, class _Sent2,
-            class _Pred,
-            class _Proj1,
-            class _Proj2>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  bool __equal_impl(_Iter1 __first1, _Sent1 __last1,
-                    _Iter2 __first2, _Sent2 __last2,
-                    _Pred& __pred,
-                    _Proj1& __proj1,
-                    _Proj2& __proj2) {
-    while (__first1 != __last1 && __first2 != __last2) {
-      if (!std::invoke(__pred, std::invoke(__proj1, *__first1), std::invoke(__proj2, *__first2)))
-        return false;
-      ++__first1;
-      ++__first2;
-    }
-    return __first1 == __last1 && __first2 == __last2;
-  }
-
-public:
-
   template <input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
             input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
             class _Pred = ranges::equal_to,
@@ -70,11 +50,13 @@
       if (__last1 - __first1 != __last2 - __first2)
         return false;
     }
-    return __equal_impl(std::move(__first1), std::move(__last1),
-                        std::move(__first2), std::move(__last2),
-                        __pred,
-                        __proj1,
-                        __proj2);
+    auto __unwrapped1 = std::__unwrap_range(std::move(__first1), std::move(__last1));
+    auto __unwrapped2 = std::__unwrap_range(std::move(__first2), std::move(__last2));
+    return std::__equal_impl(std::move(__unwrapped1.first), std::move(__unwrapped1.second),
+                             std::move(__unwrapped2.first), std::move(__unwrapped2.second),
+                             __pred,
+                             __proj1,
+                             __proj2);
   }
 
   template <input_range _Range1,
@@ -93,11 +75,13 @@
       if (ranges::distance(__range1) != ranges::distance(__range2))
         return false;
     }
-    return __equal_impl(ranges::begin(__range1), ranges::end(__range1),
-                        ranges::begin(__range2), ranges::end(__range2),
-                        __pred,
-                        __proj1,
-                        __proj2);
+    auto __unwrapped1 = std::__unwrap_range(ranges::begin(__range1), ranges::end(__range1));
+    auto __unwrapped2 = std::__unwrap_range(ranges::begin(__range2), ranges::end(__range2));
+    return std::__equal_impl(std::move(__unwrapped1.first), std::move(__unwrapped1.second),
+                             std::move(__unwrapped2.first), std::move(__unwrapped2.second),
+                             __pred,
+                             __proj1,
+                             __proj2);
     return false;
   }
 };
diff --git a/libcxx/include/__functional/identity.h b/libcxx/include/__functional/identity.h
--- a/libcxx/include/__functional/identity.h
+++ b/libcxx/include/__functional/identity.h
@@ -11,6 +11,7 @@
 #define _LIBCPP___FUNCTIONAL_IDENTITY_H
 
 #include <__config>
+#include <__type_traits/integral_constant.h>
 #include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -19,6 +20,9 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+template <class _Tp>
+struct __is_identity : false_type {};
+
 struct __identity {
   template <class _Tp>
   _LIBCPP_NODISCARD _LIBCPP_CONSTEXPR _Tp&& operator()(_Tp&& __t) const _NOEXCEPT {
@@ -28,6 +32,9 @@
   using is_transparent = void;
 };
 
+template <>
+struct __is_identity<__identity> : true_type {};
+
 #if _LIBCPP_STD_VER > 17
 
 struct identity {
@@ -39,6 +46,10 @@
 
     using is_transparent = void;
 };
+
+template <>
+struct __is_identity<identity> : true_type {};
+
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__functional/operations.h b/libcxx/include/__functional/operations.h
--- a/libcxx/include/__functional/operations.h
+++ b/libcxx/include/__functional/operations.h
@@ -13,6 +13,8 @@
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/unary_function.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_predicate_kind.h>
 #include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -341,6 +343,9 @@
 };
 #endif
 
+template <class _Tp>
+struct __is_equal_to_predicate<equal_to<_Tp>> : true_type {};
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
diff --git a/libcxx/include/__functional/ranges_operations.h b/libcxx/include/__functional/ranges_operations.h
--- a/libcxx/include/__functional/ranges_operations.h
+++ b/libcxx/include/__functional/ranges_operations.h
@@ -13,6 +13,8 @@
 #include <__concepts/equality_comparable.h>
 #include <__concepts/totally_ordered.h>
 #include <__config>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_predicate_kind.h>
 #include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -93,6 +95,9 @@
 
 } // namespace ranges
 
+template <>
+struct __is_equal_to_predicate<ranges::equal_to> : true_type {};
+
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/libcxx/include/__type_traits/is_comparable.h b/libcxx/include/__type_traits/is_comparable.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__type_traits/is_comparable.h
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_IS_COMPARABLE_H
+#define _LIBCPP___TYPE_TRAITS_IS_COMPARABLE_H
+
+#include <__config>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/remove_cv.h>
+#include <__type_traits/void_t.h>
+#include <__utility/declval.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _Up, class = void>
+struct __is_equality_comparable : false_type {};
+
+template <class _Tp, class _Up>
+struct __is_equality_comparable<_Tp, _Up, __void_t<decltype(std::declval<_Tp>() == std::declval<_Up>())>> : true_type {
+};
+
+template <class _Tp, class _Up>
+struct __is_trivially_equality_comparable
+    : integral_constant<bool,
+                        __is_equality_comparable<_Tp, _Up>::value && is_integral<_Tp>::value &&
+                            is_same<__remove_cv_t<_Tp>, __remove_cv_t<_Up>>::value> {};
+
+template <class _Tp, class _Up>
+struct __is_trivially_equality_comparable<_Tp*, _Up*> : __is_equality_comparable<_Tp*, _Up*> {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_IS_COMPARABLE_H
diff --git a/libcxx/include/__type_traits/is_predicate_kind.h b/libcxx/include/__type_traits/is_predicate_kind.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__type_traits/is_predicate_kind.h
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_IS_PREDICATE_KIND
+#define _LIBCPP___TYPE_TRAITS_IS_PREDICATE_KIND
+
+#include <__config>
+#include <__type_traits/integral_constant.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct __is_equal_to_predicate : false_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_IS_PREDICATE_KIND
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -1383,6 +1383,7 @@
     module is_callable                         { private header "__type_traits/is_callable.h" }
     module is_char_like_type                   { private header "__type_traits/is_char_like_type.h" }
     module is_class                            { private header "__type_traits/is_class.h" }
+    module is_comparable                       { private header "__type_traits/is_comparable.h" }
     module is_compound                         { private header "__type_traits/is_compound.h" }
     module is_const                            { private header "__type_traits/is_const.h" }
     module is_constant_evaluated               { private header "__type_traits/is_constant_evaluated.h" }
@@ -1421,6 +1422,7 @@
     module is_pod                              { private header "__type_traits/is_pod.h" }
     module is_pointer                          { private header "__type_traits/is_pointer.h" }
     module is_polymorphic                      { private header "__type_traits/is_polymorphic.h" }
+    module is_predicate_kind                   { private header "__type_traits/is_predicate_kind.h" }
     module is_primary_template                 { private header "__type_traits/is_primary_template.h" }
     module is_reference                        { private header "__type_traits/is_reference.h" }
     module is_reference_wrapper                { private header "__type_traits/is_reference_wrapper.h" }
diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp
--- a/libcxx/test/libcxx/private_headers.verify.cpp
+++ b/libcxx/test/libcxx/private_headers.verify.cpp
@@ -593,6 +593,7 @@
 #include <__type_traits/is_callable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_callable.h'}}
 #include <__type_traits/is_char_like_type.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_char_like_type.h'}}
 #include <__type_traits/is_class.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_class.h'}}
+#include <__type_traits/is_comparable.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_comparable.h'}}
 #include <__type_traits/is_compound.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_compound.h'}}
 #include <__type_traits/is_const.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_const.h'}}
 #include <__type_traits/is_constant_evaluated.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_constant_evaluated.h'}}
@@ -631,6 +632,7 @@
 #include <__type_traits/is_pod.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_pod.h'}}
 #include <__type_traits/is_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_pointer.h'}}
 #include <__type_traits/is_polymorphic.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_polymorphic.h'}}
+#include <__type_traits/is_predicate_kind.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_predicate_kind.h'}}
 #include <__type_traits/is_primary_template.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_primary_template.h'}}
 #include <__type_traits/is_reference.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_reference.h'}}
 #include <__type_traits/is_reference_wrapper.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/is_reference_wrapper.h'}}
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp
@@ -21,67 +21,67 @@
 #include <algorithm>
 #include <cassert>
 
-#include "test_macros.h"
 #include "test_iterators.h"
+#include "test_macros.h"
+#include "type_algorithms.h"
 
-template <class Iter1, class Iter2 = Iter1>
-void test_equal() {
-  int a[]          = {0, 1, 2, 3, 4, 5};
-  const unsigned s = sizeof(a) / sizeof(a[0]);
-  int b[s]         = {0, 1, 2, 5, 4, 5};
+template <class UnderlyingType, class Iter1>
+struct Test {
+  template <class Iter2>
+  TEST_CONSTEXPR_CXX20 void operator()() {
+    UnderlyingType a[]  = {0, 1, 2, 3, 4, 5};
+    const unsigned s    = sizeof(a) / sizeof(a[0]);
+    UnderlyingType b[s] = {0, 1, 2, 5, 4, 5};
 
-  assert(std::equal(Iter1(a), Iter1(a + s), Iter2(a)));
-  assert(std::equal(Iter2(a), Iter2(a + s), Iter1(a)));
-  assert(!std::equal(Iter1(a), Iter1(a + s), Iter2(b)));
+    assert(std::equal(Iter1(a), Iter1(a + s), Iter2(a)));
+    assert(!std::equal(Iter1(a), Iter1(a + s), Iter2(b)));
 
 #if TEST_STD_VER >= 14
-  assert(std::equal(Iter1(a), Iter1(a + s), Iter2(a), Iter2(a + s)));
-  assert(std::equal(Iter2(a), Iter2(a + s), Iter1(a), Iter1(a + s)));
-  assert(!std::equal(Iter1(a), Iter1(a + s), Iter2(a), Iter2(a + s - 1)));
-  assert(!std::equal(Iter1(a), Iter1(a + s), Iter2(b), Iter2(b + s)));
+    assert(std::equal(Iter1(a), Iter1(a + s), Iter2(a), Iter2(a + s)));
+    assert(!std::equal(Iter1(a), Iter1(a + s), Iter2(a), Iter2(a + s - 1)));
+    assert(!std::equal(Iter1(a), Iter1(a + s), Iter2(b), Iter2(b + s)));
 #endif
-}
+  }
+};
 
-#if TEST_STD_VER > 17
-TEST_CONSTEXPR bool test_constexpr() {
-    int ia[] = {1, 3, 6, 7};
-    int ib[] = {1, 3};
-    int ic[] = {1, 3, 5, 7};
-    typedef cpp17_input_iterator<int*>         II;
-    typedef bidirectional_iterator<int*> BI;
-
-    return !std::equal(std::begin(ia), std::end(ia), std::begin(ic))
-        && !std::equal(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic))
-        &&  std::equal(std::begin(ib), std::end(ib), std::begin(ic))
-        && !std::equal(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic))
-
-        &&  std::equal(II(std::begin(ib)), II(std::end(ib)), II(std::begin(ic)))
-        && !std::equal(BI(std::begin(ib)), BI(std::end(ib)), BI(std::begin(ic)), BI(std::end(ic)))
-        ;
-    }
-#endif
+template <class UnderlyingType, class TypeList>
+struct TestIter2 {
+  template <class Iter1>
+  TEST_CONSTEXPR_CXX20 void operator()() {
+    meta::for_each(TypeList(), Test<UnderlyingType, Iter1>());
+  }
+};
+
+struct AddressCompare {
+  int i = 0;
+  TEST_CONSTEXPR_CXX20 AddressCompare(int) {}
 
+  friend TEST_CONSTEXPR_CXX20 bool operator==(const AddressCompare& lhs, const AddressCompare& rhs) {
+    return &lhs == &rhs;
+  }
 
-int main(int, char**)
-{
-  test_equal<cpp17_input_iterator<const int*> >();
-  test_equal<random_access_iterator<const int*> >();
-
-  // Test all combinations of cv-qualifiers:
-  test_equal<int*>();
-  test_equal<int*, const int*>();
-  test_equal<int*, volatile int*>();
-  test_equal<int*, const volatile int*>();
-  test_equal<const int*>();
-  test_equal<const int*, volatile int*>();
-  test_equal<const int*, const volatile int*>();
-  test_equal<volatile int*>();
-  test_equal<volatile int*, const volatile int*>();
-  test_equal<const volatile int*>();
-
-#if TEST_STD_VER > 17
-    static_assert(test_constexpr());
+  friend TEST_CONSTEXPR_CXX20 bool operator!=(const AddressCompare& lhs, const AddressCompare& rhs) {
+    return &lhs != &rhs;
+  }
+};
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  meta::for_each(meta::cpp17_input_iterator_list<int*>(), TestIter2<int, meta::cpp17_input_iterator_list<int*>>());
+  meta::for_each(meta::cpp17_input_iterator_list<char*>(), TestIter2<char, meta::cpp17_input_iterator_list<char*>>());
+  meta::for_each(meta::cpp17_input_iterator_list<AddressCompare*>(),
+                 TestIter2<AddressCompare, meta::cpp17_input_iterator_list<AddressCompare*>>());
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
 #endif
 
+  meta::for_each(meta::cv_qualified_ptr<int>(), TestIter2<int, meta::cv_qualified_ptr<int>>());
+  meta::for_each(meta::cv_qualified_ptr<char>(), TestIter2<char, meta::cv_qualified_ptr<char>>());
+
   return 0;
 }
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -1298,23 +1298,31 @@
   requires std::ranges::viewable_range<R&&>
 ProxyRange(R&&) -> ProxyRange<std::views::all_t<R&&>>;
 
+#endif // TEST_STD_VER > 17
+
 namespace meta {
 template <class Ptr>
-using random_access_iterator_list = type_list<Ptr, contiguous_iterator<Ptr>, random_access_iterator<Ptr>>;
+using random_access_iterator_list = type_list<Ptr, contiguous_iterator<Ptr>, random_access_iterator<Ptr> >;
 
 template <class Ptr>
 using bidirectional_iterator_list =
-    concatenate_t<random_access_iterator_list<Ptr>, type_list<bidirectional_iterator<Ptr>>>;
+    concatenate_t<random_access_iterator_list<Ptr>, type_list<bidirectional_iterator<Ptr> > >;
+
+template <class Ptr>
+using forward_iterator_list = concatenate_t<bidirectional_iterator_list<Ptr>, type_list<forward_iterator<Ptr> > >;
 
 template <class Ptr>
-using forward_iterator_list = concatenate_t<bidirectional_iterator_list<Ptr>, type_list<forward_iterator<Ptr>>>;
+using cpp17_input_iterator_list = concatenate_t<forward_iterator_list<Ptr>, type_list<cpp17_input_iterator<Ptr> > >;
 
+#if TEST_STD_VER >= 20
 template <class Ptr>
 using cpp20_input_iterator_list =
     concatenate_t<forward_iterator_list<Ptr>, type_list<cpp20_input_iterator<Ptr>, cpp17_input_iterator<Ptr>>>;
+#endif
 
+template <class T>
+using cv_qualified_ptr = type_list<T*, const T*, volatile T*, const volatile T*>;
 } // namespace meta
 
-#endif // TEST_STD_VER > 17
 
 #endif // SUPPORT_TEST_ITERATORS_H