From 91a5dec3e37f211b14fd5921083cc563a5202195 Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Tue, 7 Jul 2026 18:55:16 -0600
Subject: [PATCH 1/2] :art: Remove `udls.hpp` dependency on `type_traits.hpp`

Problem:
- `udls.hpp` depends on `type_traits` just for `to_underlying`, but this is not
  needed.

Solution:
- Remove the `type_traits` dependency.
---
 docs/header_graph.mmd | 1 -
 include/stdx/udls.hpp | 6 +-----
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/docs/header_graph.mmd b/docs/header_graph.mmd
index 5a4fcbe..157b031 100644
--- a/docs/header_graph.mmd
+++ b/docs/header_graph.mmd
@@ -24,7 +24,6 @@ flowchart BT
   concepts(<a href="https://github.com/intel/cpp-std-extensions/tree/main/include/stdx/concepts.hpp">concepts.hpp</a>)
   concepts --> type_traits
   udls(<a href="https://github.com/intel/cpp-std-extensions/tree/main/include/stdx/udls.hpp">udls.hpp</a>)
-  udls --> type_traits
   function_traits(<a href="https://github.com/intel/cpp-std-extensions/tree/main/include/stdx/function_traits.hpp">function_traits.hpp</a>)
   function_traits --> type_traits
 
diff --git a/include/stdx/udls.hpp b/include/stdx/udls.hpp
index 4421dfd..a269f2b 100644
--- a/include/stdx/udls.hpp
+++ b/include/stdx/udls.hpp
@@ -1,8 +1,5 @@
 #pragma once
 
-#include <stdx/compiler.hpp>
-#include <stdx/type_traits.hpp>
-
 #include <cstddef>
 #include <cstdint>
 #include <type_traits>
@@ -41,8 +38,7 @@ consteval auto maybe_add_digit(Sum s) {
 
 template <auto Base, char... Cs> struct raw_parser {
     template <typename T> consteval static auto parse() {
-        using U = decltype(stdx::to_underlying(std::declval<T>()));
-        auto x = U{};
+        auto x = T{};
         ((x = maybe_add_digit<Base, Cs>(x)), ...);
         return T{x};
     }

From eb3b405d66e7191e6534955095192d0430a520be Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Tue, 7 Jul 2026 18:56:18 -0600
Subject: [PATCH 2/2] :fire: Remove `remove_cvref_t`

Problem:
- `remove_cvref_t` is a C++20 feature that has long since been available in
  supported toolchains.
- See https://cppstat.dev/?search=remove_cvref

Solution:
- Remove `remove_cvref_t`.

Note:
- Many places were already using `std::remove_cvref_t`.
---
 docs/type_traits.adoc             |  1 -
 include/stdx/byterator.hpp        |  4 ++--
 include/stdx/cached.hpp           |  3 +--
 include/stdx/call_by_need.hpp     |  4 ++--
 include/stdx/concepts.hpp         |  6 ++++--
 include/stdx/function_traits.hpp  |  4 ++--
 include/stdx/functional.hpp       |  4 ++--
 include/stdx/iterator.hpp         |  4 ++--
 include/stdx/latched.hpp          |  4 ++--
 include/stdx/optional.hpp         | 33 +++++++++++++++----------------
 include/stdx/span.hpp             |  2 +-
 include/stdx/tuple.hpp            |  2 +-
 include/stdx/tuple_algorithms.hpp |  6 +++---
 include/stdx/type_traits.hpp      |  9 ++-------
 test/CMakeLists.txt               |  1 -
 test/call_by_need.cpp             |  4 ++--
 test/remove_cvref.cpp             | 14 -------------
 test/span.cpp                     |  2 +-
 18 files changed, 43 insertions(+), 64 deletions(-)
 delete mode 100644 test/remove_cvref.cpp

diff --git a/docs/type_traits.adoc b/docs/type_traits.adoc
index 1da95ba..b0bae5f 100644
--- a/docs/type_traits.adoc
+++ b/docs/type_traits.adoc
@@ -10,7 +10,6 @@ contains a few things from the standard:
 * https://en.cppreference.com/w/cpp/types/is_constant_evaluated[`is_constant_evaluated`] (from C++20)
 * https://en.cppreference.com/w/cpp/types/is_function[`is_function_v`] (implemented with Walter Brown's method)
 * https://en.cppreference.com/w/cpp/types/is_scoped_enum[`is_scoped_enum_v`] (from C++23)
-* https://en.cppreference.com/w/cpp/types/remove_cvref[`remove_cvref_t`] (from C++20)
 * https://en.cppreference.com/w/cpp/utility/to_underlying[`to_underlying`] (from C++23)
 * https://en.cppreference.com/w/cpp/types/type_identity[`type_identity`] (from C++20)
 
diff --git a/include/stdx/byterator.hpp b/include/stdx/byterator.hpp
index deea5d3..283d821 100644
--- a/include/stdx/byterator.hpp
+++ b/include/stdx/byterator.hpp
@@ -163,9 +163,9 @@ template <typename T> class byterator {
     }
 
     template <typename V>
-        requires std::is_trivially_copyable_v<remove_cvref_t<V>>
+        requires std::is_trivially_copyable_v<std::remove_cvref_t<V>>
     auto write(V &&v) -> void {
-        using R = remove_cvref_t<V>;
+        using R = std::remove_cvref_t<V>;
         std::memcpy(ptr, std::addressof(v), sizeof(R));
         advance<R>();
     }
diff --git a/include/stdx/cached.hpp b/include/stdx/cached.hpp
index 8b12115..8006ca1 100644
--- a/include/stdx/cached.hpp
+++ b/include/stdx/cached.hpp
@@ -2,7 +2,6 @@
 
 #include <stdx/compiler.hpp>
 #include <stdx/latched.hpp>
-#include <stdx/type_traits.hpp>
 
 namespace stdx {
 inline namespace v1 {
@@ -17,7 +16,7 @@ template <typename F> struct cached : latched<F> {
     }
 };
 
-template <typename F> cached(F) -> cached<remove_cvref_t<F>>;
+template <typename F> cached(F) -> cached<std::remove_cvref_t<F>>;
 
 template <typename C> using cached_value_t = latched_value_t<C>;
 } // namespace v1
diff --git a/include/stdx/call_by_need.hpp b/include/stdx/call_by_need.hpp
index daef889..e4355cc 100644
--- a/include/stdx/call_by_need.hpp
+++ b/include/stdx/call_by_need.hpp
@@ -156,8 +156,8 @@ constexpr auto call_by_need(Fs &&fs, Args &&args) {
                 std::forward<Fs>(fs)))...>::
                 template compute_call_info<decltype(get<Js>(
                     std::forward<Args>(args)))...>();
-        }(std::make_index_sequence<tuple_size_v<remove_cvref_t<Fs>>>{},
-          std::make_index_sequence<tuple_size_v<remove_cvref_t<Args>>>{});
+        }(std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Fs>>>{},
+          std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Args>>>{});
 
     auto new_fs = [&]<std::size_t... Is>(std::index_sequence<Is...>) {
         return tuple{get<Is>(std::forward<Fs>(fs))...,
diff --git a/include/stdx/concepts.hpp b/include/stdx/concepts.hpp
index ea09f8b..3cd60e7 100644
--- a/include/stdx/concepts.hpp
+++ b/include/stdx/concepts.hpp
@@ -50,7 +50,8 @@ template <typename T, typename... Us>
 constexpr auto same_none = not same_any<T, Us...>;
 
 template <typename T, typename U>
-concept same_as_unqualified = same_as<remove_cvref_t<T>, remove_cvref_t<U>>;
+concept same_as_unqualified =
+    same_as<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;
 
 template <typename T>
 concept equality_comparable = requires(T const &t) {
@@ -137,7 +138,8 @@ template <typename T, template <typename> typename TypeTrait>
 concept has_trait = TypeTrait<T>::value;
 
 template <typename T, typename U>
-concept same_as_unqualified = same_as<remove_cvref_t<T>, remove_cvref_t<U>>;
+concept same_as_unqualified =
+    same_as<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;
 
 template <typename T>
 concept structural = is_structural_v<T>;
diff --git a/include/stdx/function_traits.hpp b/include/stdx/function_traits.hpp
index 9fc2e2e..05adb7d 100644
--- a/include/stdx/function_traits.hpp
+++ b/include/stdx/function_traits.hpp
@@ -128,8 +128,8 @@ template <typename F, typename = void> struct detect_call_operator {
 };
 template <typename F>
 struct detect_call_operator<
-    F, std::void_t<decltype(&remove_cvref_t<F>::operator())>>
-    : function_traits<decltype(&remove_cvref_t<F>::operator())> {};
+    F, std::void_t<decltype(&std::remove_cvref_t<F>::operator())>>
+    : function_traits<decltype(&std::remove_cvref_t<F>::operator())> {};
 
 template <typename F> struct function_traits : detect_call_operator<F> {};
 } // namespace detail
diff --git a/include/stdx/functional.hpp b/include/stdx/functional.hpp
index 291c947..c5355b9 100644
--- a/include/stdx/functional.hpp
+++ b/include/stdx/functional.hpp
@@ -56,7 +56,7 @@ struct bind_front_t<F, std::index_sequence<Is...>, BoundArgs...> {
 
 template <typename F, typename... Args>
 constexpr auto bind_front(F &&f, Args &&...args) {
-    return detail::bind_front_t<stdx::remove_cvref_t<F>,
+    return detail::bind_front_t<std::remove_cvref_t<F>,
                                 std::make_index_sequence<sizeof...(Args)>,
                                 std::decay_t<Args>...>{
         std::forward<F>(f), {std::forward<Args>(args)...}};
@@ -112,7 +112,7 @@ struct bind_back_t<F, std::index_sequence<Is...>, BoundArgs...> {
 
 template <typename F, typename... Args>
 constexpr auto bind_back(F &&f, Args &&...args) {
-    return detail::bind_back_t<stdx::remove_cvref_t<F>,
+    return detail::bind_back_t<std::remove_cvref_t<F>,
                                std::make_index_sequence<sizeof...(Args)>,
                                std::decay_t<Args>...>{
         std::forward<F>(f), {std::forward<Args>(args)...}};
diff --git a/include/stdx/iterator.hpp b/include/stdx/iterator.hpp
index da7a324..90f7acc 100644
--- a/include/stdx/iterator.hpp
+++ b/include/stdx/iterator.hpp
@@ -13,7 +13,7 @@ namespace stdx {
 inline namespace v1 {
 namespace detail {
 template <typename T> struct ct_capacity_fail {
-    static_assert(always_false_v<stdx::remove_cvref_t<T>>,
+    static_assert(always_false_v<std::remove_cvref_t<T>>,
                   "Type does not support compile-time capacity");
 };
 } // namespace detail
@@ -31,7 +31,7 @@ template <typename T> constexpr auto ct_capacity_v<T const> = ct_capacity_v<T>;
 
 template <typename T>
 consteval auto ct_capacity([[maybe_unused]] T &&) -> std::size_t {
-    return ct_capacity_v<remove_cvref_t<T>>;
+    return ct_capacity_v<std::remove_cvref_t<T>>;
 }
 
 template <typename T = int, typename = std::enable_if_t<std::is_integral_v<T>>>
diff --git a/include/stdx/latched.hpp b/include/stdx/latched.hpp
index 20a78c7..12a6bad 100644
--- a/include/stdx/latched.hpp
+++ b/include/stdx/latched.hpp
@@ -11,7 +11,7 @@
 namespace stdx {
 inline namespace v1 {
 template <typename F> struct latched {
-    using value_type = stdx::remove_cvref_t<std::invoke_result_t<F>>;
+    using value_type = std::remove_cvref_t<std::invoke_result_t<F>>;
 
     constexpr explicit latched(F const &f) : lazy{f} {}
     constexpr explicit latched(F &&f) : lazy{std::move(f)} {}
@@ -56,6 +56,6 @@ template <typename F> struct latched {
 };
 
 template <typename C>
-using latched_value_t = typename stdx::remove_cvref_t<C>::value_type;
+using latched_value_t = typename std::remove_cvref_t<C>::value_type;
 } // namespace v1
 } // namespace stdx
diff --git a/include/stdx/optional.hpp b/include/stdx/optional.hpp
index 00a5b49..a8bb172 100644
--- a/include/stdx/optional.hpp
+++ b/include/stdx/optional.hpp
@@ -79,10 +79,10 @@ struct unwrap_invoker<Func, L<Ts...>,
 
 template <typename F, typename Arg>
 constexpr auto unwrap_invoke(F &&f, Arg &&arg) {
-    return unwrap_invoker<stdx::remove_cvref_t<F>,
-                          stdx::remove_cvref_t<Arg>>::invoke(std::forward<F>(f),
-                                                             std::forward<Arg>(
-                                                                 arg));
+    return unwrap_invoker<std::remove_cvref_t<F>,
+                          std::remove_cvref_t<Arg>>::invoke(std::forward<F>(f),
+                                                            std::forward<Arg>(
+                                                                arg));
 }
 
 template <typename F, typename Arg>
@@ -109,10 +109,9 @@ template <typename T, typename TS = tombstone_traits<T>> class optional {
         : val{std::forward<Args>(args)...} {}
 
     template <typename U = T>
-        requires(
-            std::is_constructible_v<T, U &&> and
-            not std::is_same_v<stdx::remove_cvref_t<U>, std::in_place_t> and
-            not std::is_same_v<stdx::remove_cvref_t<U>, optional>)
+        requires(std::is_constructible_v<T, U &&> and
+                 not std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> and
+                 not std::is_same_v<std::remove_cvref_t<U>, optional>)
     constexpr explicit optional(U &&u) : val{std::forward<U>(u)} {}
 
     constexpr auto operator=(std::nullopt_t) -> optional & {
@@ -123,7 +122,7 @@ template <typename T, typename TS = tombstone_traits<T>> class optional {
     template <typename U = T>
         requires(std::is_constructible_v<T, U> and
                  std::is_assignable_v<T &, U> and
-                 not std::is_same_v<stdx::remove_cvref_t<U>, optional> and
+                 not std::is_same_v<std::remove_cvref_t<U>, optional> and
                  (std::is_scalar_v<T> or
                   not std::is_same_v<std::decay_t<U>, T>))
     constexpr auto operator=(U &&u) -> optional & {
@@ -310,27 +309,27 @@ template <typename T> optional(T) -> optional<T>;
 namespace detail {
 template <typename T>
 concept optional_like =
-    stdx::is_specialization_of_v<stdx::remove_cvref_t<T>, optional> or
-    stdx::is_specialization_of_v<stdx::remove_cvref_t<T>, std::optional>;
+    stdx::is_specialization_of_v<std::remove_cvref_t<T>, optional> or
+    stdx::is_specialization_of_v<std::remove_cvref_t<T>, std::optional>;
 
 template <typename R, typename... Ts,
-          typename = std::enable_if_t<
-              (... and stdx::is_specialization_of_v<stdx::remove_cvref_t<Ts>,
-                                                    optional>)>>
+          typename = std::enable_if_t<(
+              ... and
+              stdx::is_specialization_of_v<std::remove_cvref_t<Ts>, optional>)>>
 auto convert_optional(Ts const &...) -> optional<R>;
 template <typename R, typename... Ts,
           typename = std::enable_if_t<
-              (... and stdx::is_specialization_of_v<stdx::remove_cvref_t<Ts>,
+              (... and stdx::is_specialization_of_v<std::remove_cvref_t<Ts>,
                                                     std::optional>)>>
 auto convert_optional(Ts const &...) -> std::optional<R>;
 } // namespace detail
 
 template <typename F, detail::optional_like... Ts>
 constexpr auto transform(F &&f, Ts &&...ts) {
-    using func_t = stdx::remove_cvref_t<F>;
+    using func_t = std::remove_cvref_t<F>;
     using R = std::invoke_result_t<
         func_t,
-        forward_like_t<Ts, typename stdx::remove_cvref_t<Ts>::value_type>...>;
+        forward_like_t<Ts, typename std::remove_cvref_t<Ts>::value_type>...>;
     using O = decltype(detail::convert_optional<R>(ts...));
     if ((... and ts.has_value())) {
         return O{with_result_of{[&] {
diff --git a/include/stdx/span.hpp b/include/stdx/span.hpp
index 316979f..4671d08 100644
--- a/include/stdx/span.hpp
+++ b/include/stdx/span.hpp
@@ -66,7 +66,7 @@ class span : public detail::span_base<T, Extent> {
 
   public:
     using element_type = T;
-    using value_type = stdx::remove_cvref_t<T>;
+    using value_type = std::remove_cvref_t<T>;
     using size_type = std::size_t;
     using difference_type = std::ptrdiff_t;
     using pointer = T *;
diff --git a/include/stdx/tuple.hpp b/include/stdx/tuple.hpp
index 213c3d8..73f0617 100644
--- a/include/stdx/tuple.hpp
+++ b/include/stdx/tuple.hpp
@@ -432,7 +432,7 @@ template <typename T>
 concept tuple_comparable = requires { typename T::common_tuple_comparable; };
 
 template <typename T>
-concept tuplelike = requires { typename remove_cvref_t<T>::is_tuple; };
+concept tuplelike = requires { typename std::remove_cvref_t<T>::is_tuple; };
 
 template <std::size_t I, typename T> struct tuple_element;
 
diff --git a/include/stdx/tuple_algorithms.hpp b/include/stdx/tuple_algorithms.hpp
index 30851b2..fbc65a5 100644
--- a/include/stdx/tuple_algorithms.hpp
+++ b/include/stdx/tuple_algorithms.hpp
@@ -271,7 +271,7 @@ constexpr auto contains_type =
 template <template <typename> typename Proj = std::type_identity_t,
           tuplelike Tuple>
 [[nodiscard]] constexpr auto sort(Tuple &&t) {
-    using T = stdx::remove_cvref_t<Tuple>;
+    using T = std::remove_cvref_t<Tuple>;
     constexpr auto indices = detail::sorted_indices<T, Proj>();
     return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
         return stdx::tuple<tuple_element_t<indices[Is], T>...>{
@@ -344,7 +344,7 @@ template <template <typename> typename Proj = std::type_identity_t,
                 [&]<std::size_t... Js>(std::index_sequence<Js...>) {
                     constexpr auto offset = chunks[Is].offset;
                     return stdx::tuple<tuple_element_t<
-                        offset + Js, stdx::remove_cvref_t<Tuple>>...>{
+                        offset + Js, std::remove_cvref_t<Tuple>>...>{
                         std::forward<Tuple>(t)[index<offset + Js>]...};
                 }(std::make_index_sequence<chunks[Is].size>{})...);
         }(std::make_index_sequence<chunks.size()>{});
@@ -409,7 +409,7 @@ template <tuplelike T> constexpr auto to_sorted_set(T &&t) {
 }
 
 template <tuplelike Tuple> constexpr auto to_unsorted_set(Tuple &&t) {
-    using T = stdx::remove_cvref_t<Tuple>;
+    using T = std::remove_cvref_t<Tuple>;
     using U = boost::mp11::mp_unique<T>;
     return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
         return U{get<boost::mp11::mp_find<T, tuple_element_t<Is, U>>::value>(
diff --git a/include/stdx/type_traits.hpp b/include/stdx/type_traits.hpp
index 2ce0c4f..cdbae91 100644
--- a/include/stdx/type_traits.hpp
+++ b/include/stdx/type_traits.hpp
@@ -21,11 +21,6 @@ template <typename E> constexpr auto to_underlying(E e) noexcept {
 template <typename E>
 using underlying_type_t = decltype(to_underlying(std::declval<E>()));
 
-template <typename T> struct remove_cvref {
-    using type = std::remove_cv_t<std::remove_reference_t<T>>;
-};
-template <typename T> using remove_cvref_t = typename remove_cvref<T>::type;
-
 namespace detail {
 template <bool> struct conditional;
 
@@ -54,7 +49,7 @@ struct call_base {
 
 template <typename, bool> struct callable_test : call_base {};
 template <typename F>
-struct callable_test<F, true> : remove_cvref_t<F>, call_base {};
+struct callable_test<F, true> : std::remove_cvref_t<F>, call_base {};
 
 template <typename F, typename = void> constexpr auto is_func_obj = true;
 template <typename F>
@@ -189,7 +184,7 @@ constexpr static auto apply_sequence = detail::apply_sequence_t<L>{};
 
 template <typename T, typename U>
 constexpr bool is_same_unqualified_v =
-    std::is_same_v<remove_cvref_t<T>, remove_cvref_t<U>>;
+    std::is_same_v<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;
 
 namespace detail {
 template <typename T> struct any_t;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 490128d..ea04c68 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -63,7 +63,6 @@ add_tests(
     pp_map
     priority
     ranges
-    remove_cvref
     rollover
     span
     to_underlying
diff --git a/test/call_by_need.cpp b/test/call_by_need.cpp
index 7443ced..ac44a7b 100644
--- a/test/call_by_need.cpp
+++ b/test/call_by_need.cpp
@@ -11,8 +11,8 @@ template <auto V> constexpr auto arg = arg_t<V>{};
 
 template <auto V1, auto V2>
 constexpr auto operator==(arg_t<V1>, arg_t<V2>) -> bool {
-    if constexpr (std::is_same_v<stdx::remove_cvref_t<decltype(V1)>,
-                                 stdx::remove_cvref_t<decltype(V2)>>) {
+    if constexpr (std::is_same_v<std::remove_cvref_t<decltype(V1)>,
+                                 std::remove_cvref_t<decltype(V2)>>) {
         return V1 == V2;
     }
     return false;
diff --git a/test/remove_cvref.cpp b/test/remove_cvref.cpp
deleted file mode 100644
index ea987f9..0000000
--- a/test/remove_cvref.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdx/type_traits.hpp>
-
-#include <catch2/catch_test_macros.hpp>
-
-#include <type_traits>
-
-TEST_CASE("remove_cvref", "[type_traits]") {
-    REQUIRE(std::is_same_v<stdx::remove_cvref_t<int>, int>);
-    REQUIRE(std::is_same_v<stdx::remove_cvref_t<int const>, int>);
-    REQUIRE(std::is_same_v<stdx::remove_cvref_t<int &>, int>);
-    REQUIRE(std::is_same_v<stdx::remove_cvref_t<int const &>, int>);
-    REQUIRE(std::is_same_v<stdx::remove_cvref_t<int &&>, int>);
-    REQUIRE(std::is_same_v<stdx::remove_cvref_t<int const &&>, int>);
-}
diff --git a/test/span.cpp b/test/span.cpp
index c13c287..7a65c8a 100644
--- a/test/span.cpp
+++ b/test/span.cpp
@@ -16,7 +16,7 @@ TEMPLATE_TEST_CASE("span exposes types", "[span]", std::uint8_t,
     using S = stdx::span<TestType>;
     STATIC_REQUIRE(std::is_same_v<typename S::element_type, TestType>);
     STATIC_REQUIRE(
-        std::is_same_v<typename S::value_type, stdx::remove_cvref_t<TestType>>);
+        std::is_same_v<typename S::value_type, std::remove_cvref_t<TestType>>);
     STATIC_REQUIRE(std::is_same_v<typename S::size_type, std::size_t>);
     STATIC_REQUIRE(std::is_same_v<typename S::difference_type, std::ptrdiff_t>);
     STATIC_REQUIRE(std::is_same_v<typename S::pointer, TestType *>);