stl: std::remove_const_t

src/entt/container/dense_set.hpp

@@ -35,7 +35,7 @@ class dense_set_iterator final {
     static_assert(stl::is_pointer_v<It>, "Not a pointer type");
 
 public:
-    using value_type = std::remove_const_t<stl::remove_pointer_t<It>>::second_type;
+    using value_type = stl::remove_const_t<stl::remove_pointer_t<It>>::second_type;
     using pointer = const value_type *;
     using reference = const value_type &;
     using difference_type = std::ptrdiff_t;
@@ -127,7 +127,7 @@ class dense_set_local_iterator final {
     static_assert(stl::is_pointer_v<It>, "Not a pointer type");
 
 public:
-    using value_type = std::remove_const_t<stl::remove_pointer_t<It>>::second_type;
+    using value_type = stl::remove_const_t<stl::remove_pointer_t<It>>::second_type;
     using pointer = const value_type *;
     using reference = const value_type &;
     using difference_type = std::ptrdiff_t;

src/entt/core/any.hpp

@@ -382,7 +382,7 @@ public:
      */
     template<typename Type>
     [[nodiscard]] const Type *data() const noexcept {
-        return has_value<std::remove_const_t<Type>>() ? static_cast<const Type *>(data()) : nullptr;
+        return has_value<stl::remove_const_t<Type>>() ? static_cast<const Type *>(data()) : nullptr;
     }
 
     /**
@@ -410,9 +410,9 @@ public:
     template<typename Type>
     [[nodiscard]] Type *data() noexcept {
         if constexpr(std::is_const_v<Type>) {
-            return stl::as_const(*this).template data<std::remove_const_t<Type>>();
+            return stl::as_const(*this).template data<stl::remove_const_t<Type>>();
         } else {
-            return (mode == any_policy::cref) ? nullptr : const_cast<Type *>(stl::as_const(*this).template data<std::remove_const_t<Type>>());
+            return (mode == any_policy::cref) ? nullptr : const_cast<Type *>(stl::as_const(*this).template data<stl::remove_const_t<Type>>());
         }
     }
 
@@ -541,7 +541,7 @@ private:
  * @return The element converted to the requested type.
  */
 template<typename Type, std::size_t Len, std::size_t Align>
-[[nodiscard]] std::remove_const_t<Type> any_cast(const basic_any<Len, Align> &data) noexcept {
+[[nodiscard]] stl::remove_const_t<Type> any_cast(const basic_any<Len, Align> &data) noexcept {
     const auto *const instance = any_cast<stl::remove_reference_t<Type>>(&data);
     ENTT_ASSERT(instance, "Invalid instance");
     return static_cast<Type>(*instance);
@@ -549,7 +549,7 @@ template<typename Type, std::size_t Len, std::size_t Align>
 
 /*! @copydoc any_cast */
 template<typename Type, std::size_t Len, std::size_t Align>
-[[nodiscard]] std::remove_const_t<Type> any_cast(basic_any<Len, Align> &data) noexcept {
+[[nodiscard]] stl::remove_const_t<Type> any_cast(basic_any<Len, Align> &data) noexcept {
     // forces const on non-reference types to make them work also with wrappers for const references
     auto *const instance = any_cast<stl::remove_reference_t<const Type>>(&data);
     ENTT_ASSERT(instance, "Invalid instance");
@@ -559,7 +559,7 @@ template<typename Type, std::size_t Len, std::size_t Align>
 /*! @copydoc any_cast */
 template<typename Type, std::size_t Len, std::size_t Align>
 // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
-[[nodiscard]] std::remove_const_t<Type> any_cast(basic_any<Len, Align> &&data) noexcept {
+[[nodiscard]] stl::remove_const_t<Type> any_cast(basic_any<Len, Align> &&data) noexcept {
     if constexpr(std::is_copy_constructible_v<stl::remove_cvref_t<Type>>) {
         if(auto *const instance = any_cast<stl::remove_reference_t<Type>>(&data); instance) {
             return static_cast<Type>(stl::move(*instance));
@@ -576,7 +576,7 @@ template<typename Type, std::size_t Len, std::size_t Align>
 /*! @copydoc any_cast */
 template<typename Type, std::size_t Len, std::size_t Align>
 [[nodiscard]] const Type *any_cast(const basic_any<Len, Align> *data) noexcept {
-    return data->template data<std::remove_const_t<Type>>();
+    return data->template data<stl::remove_const_t<Type>>();
 }
 
 /*! @copydoc any_cast */

src/entt/core/type_traits.hpp

@@ -674,7 +674,7 @@ struct has_iterator_category<Type>: stl::true_type {};
 
 /*! @copydoc is_iterator */
 template<typename Type>
-requires (!stl::is_void_v<std::remove_const_t<stl::remove_pointer_t<Type>>>)
+requires (!stl::is_void_v<stl::remove_const_t<stl::remove_pointer_t<Type>>>)
 struct is_iterator<Type>: internal::has_iterator_category<Type> {};
 
 /**
@@ -759,7 +759,7 @@ template<typename Type>
     // NOLINTBEGIN(modernize-use-transparent-functors)
     if constexpr(std::is_array_v<Type>) {
         return false;
-    } else if constexpr(is_complete_v<stl::tuple_size<std::remove_const_t<Type>>>) {
+    } else if constexpr(is_complete_v<stl::tuple_size<stl::remove_const_t<Type>>>) {
         if constexpr(has_tuple_size_value<Type>::value) {
             return maybe_equality_comparable<Type>(0) && unpack_maybe_equality_comparable<Type>(std::make_index_sequence<stl::tuple_size<Type>::value>{});
         } else {
@@ -807,7 +807,7 @@ inline constexpr bool is_equality_comparable_v = is_equality_comparable<Type>::v
 template<typename To, typename From>
 struct constness_as {
     /*! @brief The type resulting from the transcription of the constness. */
-    using type = std::remove_const_t<To>;
+    using type = stl::remove_const_t<To>;
 };
 
 /*! @copydoc constness_as */

src/entt/entity/fwd.hpp

@@ -256,10 +256,10 @@ using storage_type_t = storage_type<Args...>::type;
  * @tparam Entity A valid entity type.
  * @tparam Allocator Type of allocator used to manage memory and elements.
  */
-template<typename Type, typename Entity = entity, typename Allocator = std::allocator<std::remove_const_t<Type>>>
+template<typename Type, typename Entity = entity, typename Allocator = std::allocator<stl::remove_const_t<Type>>>
 struct storage_for {
     /*! @brief Type-to-storage conversion result. */
-    using type = constness_as_t<storage_type_t<std::remove_const_t<Type>, Entity, Allocator>, Type>;
+    using type = constness_as_t<storage_type_t<stl::remove_const_t<Type>, Entity, Allocator>, Type>;
 };
 
 /**

src/entt/entity/group.hpp

@@ -277,7 +277,7 @@ class basic_group<owned_t<>, get_t<Get...>, exclude_t<Exclude...>> {
     using underlying_type = base_type::entity_type;
 
     template<typename Type>
-    static constexpr std::size_t index_of = type_list_index_v<std::remove_const_t<Type>, type_list<typename Get::element_type..., typename Exclude::element_type...>>;
+    static constexpr std::size_t index_of = type_list_index_v<stl::remove_const_t<Type>, type_list<typename Get::element_type..., typename Exclude::element_type...>>;
 
     template<std::size_t... Index>
     [[nodiscard]] auto pools_for(std::index_sequence<Index...>) const noexcept {
@@ -308,7 +308,7 @@ public:
      * @return Group opaque identifier.
      */
     static id_type group_id() noexcept {
-        return type_hash<basic_group<owned_t<>, get_t<std::remove_const_t<Get>...>, exclude_t<std::remove_const_t<Exclude>...>>>::value();
+        return type_hash<basic_group<owned_t<>, get_t<stl::remove_const_t<Get>...>, exclude_t<stl::remove_const_t<Exclude>...>>>::value();
     }
 
     /*! @brief Default constructor to use to create empty, invalid groups. */
@@ -691,7 +691,7 @@ class basic_group<owned_t<Owned...>, get_t<Get...>, exclude_t<Exclude...>> {
     using underlying_type = base_type::entity_type;
 
     template<typename Type>
-    static constexpr std::size_t index_of = type_list_index_v<std::remove_const_t<Type>, type_list<typename Owned::element_type..., typename Get::element_type..., typename Exclude::element_type...>>;
+    static constexpr std::size_t index_of = type_list_index_v<stl::remove_const_t<Type>, type_list<typename Owned::element_type..., typename Get::element_type..., typename Exclude::element_type...>>;
 
     template<std::size_t... Index, std::size_t... Other>
     [[nodiscard]] auto pools_for(std::index_sequence<Index...>, std::index_sequence<Other...>) const noexcept {
@@ -722,7 +722,7 @@ public:
      * @return Group opaque identifier.
      */
     static id_type group_id() noexcept {
-        return type_hash<basic_group<owned_t<std::remove_const_t<Owned>...>, get_t<std::remove_const_t<Get>...>, exclude_t<std::remove_const_t<Exclude>...>>>::value();
+        return type_hash<basic_group<owned_t<stl::remove_const_t<Owned>...>, get_t<stl::remove_const_t<Get>...>, exclude_t<stl::remove_const_t<Exclude>...>>>::value();
     }
 
     /*! @brief Default constructor to use to create empty, invalid groups. */

src/entt/entity/handle.hpp

@@ -353,7 +353,7 @@ public:
      */
     template<typename Other, typename... Args>
     operator basic_handle<Other, Args...>() const noexcept {
-        static_assert(stl::is_same_v<Other, Registry> || stl::is_same_v<std::remove_const_t<Other>, Registry>, "Invalid conversion between different handles");
+        static_assert(stl::is_same_v<Other, Registry> || stl::is_same_v<stl::remove_const_t<Other>, Registry>, "Invalid conversion between different handles");
         static_assert((sizeof...(Scope) == 0 || ((sizeof...(Args) != 0 && sizeof...(Args) <= sizeof...(Scope)) && ... && (type_list_contains_v<type_list<Scope...>, Args>))), "Invalid conversion between different handles");
         return owner ? basic_handle<Other, Args...>{*owner, entt} : basic_handle<Other, Args...>{};
     }

src/entt/entity/mixin.hpp

@@ -562,7 +562,7 @@ public:
     view(exclude_t<Exclude...> = exclude_t{}) const {
         const owner_type &parent = owner_or_assert();
         basic_view<get_t<const basic_reactive_mixin, typename basic_registry_type::template storage_for_type<const Get>...>, exclude_t<typename basic_registry_type::template storage_for_type<const Exclude>...>> elem{};
-        [&elem](const auto *...curr) { ((curr ? elem.storage(*curr) : void()), ...); }(parent.template storage<std::remove_const_t<Exclude>>()..., parent.template storage<std::remove_const_t<Get>>()..., this);
+        [&elem](const auto *...curr) { ((curr ? elem.storage(*curr) : void()), ...); }(parent.template storage<stl::remove_const_t<Exclude>>()..., parent.template storage<stl::remove_const_t<Get>>()..., this);
         return elem;
     }
 
@@ -571,7 +571,7 @@ public:
     [[nodiscard]] basic_view<get_t<const basic_reactive_mixin, typename basic_registry_type::template storage_for_type<Get>...>, exclude_t<typename basic_registry_type::template storage_for_type<Exclude>...>>
     view(exclude_t<Exclude...> = exclude_t{}) {
         std::conditional_t<((std::is_const_v<Get> && ...) && (std::is_const_v<Exclude> && ...)), const owner_type, owner_type> &parent = owner_or_assert();
-        return {*this, parent.template storage<std::remove_const_t<Get>>()..., parent.template storage<std::remove_const_t<Exclude>>()...};
+        return {*this, parent.template storage<stl::remove_const_t<Get>>()..., parent.template storage<stl::remove_const_t<Exclude>>()...};
     }
 
     /*! @brief Releases all connections to the underlying registry, if any. */

src/entt/entity/organizer.hpp

@@ -39,12 +39,12 @@ inline constexpr bool is_group_v = is_group<Type>::value;
 template<typename Type, typename Override>
 struct unpack_type {
     using ro = std::conditional_t<
-        type_list_contains_v<Override, const Type> || (std::is_const_v<Type> && !type_list_contains_v<Override, std::remove_const_t<Type>>),
-        type_list<std::remove_const_t<Type>>,
+        type_list_contains_v<Override, const Type> || (std::is_const_v<Type> && !type_list_contains_v<Override, stl::remove_const_t<Type>>),
+        type_list<stl::remove_const_t<Type>>,
         type_list<>>;
 
     using rw = std::conditional_t<
-        type_list_contains_v<Override, std::remove_const_t<Type>> || (!std::is_const_v<Type> && !type_list_contains_v<Override, const Type>),
+        type_list_contains_v<Override, stl::remove_const_t<Type>> || (!std::is_const_v<Type> && !type_list_contains_v<Override, const Type>),
         type_list<Type>,
         type_list<>>;
 };
@@ -84,7 +84,7 @@ struct resource_traits;
 
 template<typename Registry, typename... Args, typename... Req>
 struct resource_traits<Registry, type_list<Args...>, type_list<Req...>> {
-    using args = type_list<std::remove_const_t<Args>...>;
+    using args = type_list<stl::remove_const_t<Args>...>;
     using ro = type_list_cat_t<typename unpack_type<Args, type_list<Req...>>::ro..., typename unpack_type<Req, type_list<>>::ro...>;
     using rw = type_list_cat_t<typename unpack_type<Args, type_list<Req...>>::rw..., typename unpack_type<Req, type_list<>>::rw...>;
     static constexpr auto sync_point = (stl::is_same_v<Args, Registry> || ...);

src/entt/entity/registry.hpp

@@ -285,7 +285,7 @@ public:
      * @tparam Type Storage value type, eventually const.
      */
     template<typename Type>
-    using storage_for_type = storage_for<Type, Entity, typename alloc_traits::template rebind_alloc<std::remove_const_t<Type>>>::type;
+    using storage_for_type = storage_for<Type, Entity, typename alloc_traits::template rebind_alloc<stl::remove_const_t<Type>>>::type;
 
     /*! @brief Default constructor. */
     basic_registry()
@@ -414,7 +414,7 @@ public:
      */
     template<typename Type>
     storage_for_type<Type> &storage(const id_type id = type_hash<Type>::value()) {
-        return assure<std::remove_const_t<Type>>(id);
+        return assure<stl::remove_const_t<Type>>(id);
     }
 
     /**
@@ -425,7 +425,7 @@ public:
      */
     template<typename Type>
     [[nodiscard]] const storage_for_type<Type> *storage(const id_type id = type_hash<Type>::value()) const {
-        return assure<std::remove_const_t<Type>>(id);
+        return assure<stl::remove_const_t<Type>>(id);
     }
 
     /**
@@ -814,7 +814,7 @@ public:
     template<typename... Type>
     [[nodiscard]] bool all_of([[maybe_unused]] const entity_type entt) const {
         if constexpr(sizeof...(Type) == 1u) {
-            auto *cpool = assure<std::remove_const_t<Type>...>();
+            auto *cpool = assure<stl::remove_const_t<Type>...>();
             return cpool && cpool->contains(entt);
         } else {
             return (all_of<Type>(entt) && ...);
@@ -847,7 +847,7 @@ public:
     template<typename... Type>
     [[nodiscard]] decltype(auto) get([[maybe_unused]] const entity_type entt) const {
         if constexpr(sizeof...(Type) == 1u) {
-            return (assure<std::remove_const_t<Type>>()->get(entt), ...);
+            return (assure<stl::remove_const_t<Type>>()->get(entt), ...);
         } else {
             return stl::forward_as_tuple(get<Type>(entt)...);
         }
@@ -857,7 +857,7 @@ public:
     template<typename... Type>
     [[nodiscard]] decltype(auto) get([[maybe_unused]] const entity_type entt) {
         if constexpr(sizeof...(Type) == 1u) {
-            return (static_cast<storage_for_type<Type> &>(assure<std::remove_const_t<Type>>()).get(entt), ...);
+            return (static_cast<storage_for_type<Type> &>(assure<stl::remove_const_t<Type>>()).get(entt), ...);
         } else {
             return stl::forward_as_tuple(get<Type>(entt)...);
         }
@@ -898,7 +898,7 @@ public:
     template<typename... Type>
     [[nodiscard]] auto try_get([[maybe_unused]] const entity_type entt) const {
         if constexpr(sizeof...(Type) == 1u) {
-            const auto *cpool = assure<std::remove_const_t<Type>...>();
+            const auto *cpool = assure<stl::remove_const_t<Type>...>();
             return (cpool && cpool->contains(entt)) ? std::addressof(cpool->get(entt)) : nullptr;
         } else {
             return stl::make_tuple(try_get<Type>(entt)...);
@@ -1025,7 +1025,7 @@ public:
     [[nodiscard]] basic_view<get_t<storage_for_type<const Type>, storage_for_type<const Other>...>, exclude_t<storage_for_type<const Exclude>...>>
     view(exclude_t<Exclude...> = exclude_t{}) const {
         basic_view<get_t<storage_for_type<const Type>, storage_for_type<const Other>...>, exclude_t<storage_for_type<const Exclude>...>> elem{};
-        [&elem](const auto *...curr) { ((curr ? elem.storage(*curr) : void()), ...); }(assure<std::remove_const_t<Exclude>>()..., assure<std::remove_const_t<Other>>()..., assure<std::remove_const_t<Type>>());
+        [&elem](const auto *...curr) { ((curr ? elem.storage(*curr) : void()), ...); }(assure<stl::remove_const_t<Exclude>>()..., assure<stl::remove_const_t<Other>>()..., assure<stl::remove_const_t<Type>>());
         return elem;
     }
 
@@ -1033,7 +1033,7 @@ public:
     template<typename Type, typename... Other, typename... Exclude>
     [[nodiscard]] basic_view<get_t<storage_for_type<Type>, storage_for_type<Other>...>, exclude_t<storage_for_type<Exclude>...>>
     view(exclude_t<Exclude...> = exclude_t{}) {
-        return {assure<std::remove_const_t<Type>>(), assure<std::remove_const_t<Other>>()..., assure<std::remove_const_t<Exclude>>()...};
+        return {assure<stl::remove_const_t<Type>>(), assure<stl::remove_const_t<Other>>()..., assure<stl::remove_const_t<Exclude>>()...};
     }
 
     /**
@@ -1056,9 +1056,9 @@ public:
         std::shared_ptr<handler_type> handler{};
 
         if constexpr(sizeof...(Owned) == 0u) {
-            handler = std::allocate_shared<handler_type>(get_allocator(), get_allocator(), stl::forward_as_tuple(assure<std::remove_const_t<Get>>()...), stl::forward_as_tuple(assure<std::remove_const_t<Exclude>>()...));
+            handler = std::allocate_shared<handler_type>(get_allocator(), get_allocator(), stl::forward_as_tuple(assure<stl::remove_const_t<Get>>()...), stl::forward_as_tuple(assure<stl::remove_const_t<Exclude>>()...));
         } else {
-            handler = std::allocate_shared<handler_type>(get_allocator(), stl::forward_as_tuple(assure<std::remove_const_t<Owned>>()..., assure<std::remove_const_t<Get>>()...), stl::forward_as_tuple(assure<std::remove_const_t<Exclude>>()...));
+            handler = std::allocate_shared<handler_type>(get_allocator(), stl::forward_as_tuple(assure<stl::remove_const_t<Owned>>()..., assure<stl::remove_const_t<Get>>()...), stl::forward_as_tuple(assure<stl::remove_const_t<Exclude>>()...));
             ENTT_ASSERT(std::all_of(groups.cbegin(), groups.cend(), [](const auto &data) { return !(data.second->owned(type_id<Owned>().hash()) || ...); }), "Conflicting groups");
         }
 

src/entt/entity/snapshot.hpp

@@ -320,7 +320,7 @@ class basic_continuous_loader {
         Container other;
 
         for(auto &&pair: container) {
-            using first_type = std::remove_const_t<typename std::decay_t<decltype(pair)>::first_type>;
+            using first_type = stl::remove_const_t<typename std::decay_t<decltype(pair)>::first_type>;
             using second_type = std::decay_t<decltype(pair)>::second_type;
 
             if constexpr(stl::is_same_v<first_type, entity_type> && stl::is_same_v<second_type, entity_type>) {

src/entt/entity/sparse_set.hpp

@@ -147,7 +147,7 @@ class basic_sparse_set {
 
     // it could be auto but gcc complains and emits a warning due to a false positive
     [[nodiscard]] std::size_t policy_to_head() const noexcept {
-        return static_cast<size_type>(max_size * static_cast<std::remove_const_t<decltype(max_size)>>(mode != deletion_policy::swap_only));
+        return static_cast<size_type>(max_size * static_cast<stl::remove_const_t<decltype(max_size)>>(mode != deletion_policy::swap_only));
     }
 
     [[nodiscard]] auto entity_to_pos(const Entity entt) const noexcept {

src/entt/entity/storage.hpp

@@ -31,7 +31,7 @@ class storage_iterator final {
     template<typename, auto>
     friend class storage_iterator;
 
-    using container_type = std::remove_const_t<Container>;
+    using container_type = stl::remove_const_t<Container>;
     using alloc_traits = std::allocator_traits<typename container_type::allocator_type>;
 
     using iterator_traits = stl::iterator_traits<std::conditional_t<
@@ -52,7 +52,7 @@ public:
         : payload{ref},
           offset{idx} {}
 
-    template<std::same_as<std::remove_const_t<Container>> Other>
+    template<std::same_as<stl::remove_const_t<Container>> Other>
     requires std::is_const_v<Container>
     constexpr storage_iterator(const storage_iterator<Other, Page> &other) noexcept
         : storage_iterator{other.payload, other.offset} {}

src/entt/entity/view.hpp

@@ -415,7 +415,7 @@ class basic_view<get_t<Get...>, exclude_t<Exclude...>>
     using element_at = type_list_element_t<Index, type_list<Get..., Exclude...>>;
 
     template<typename Type>
-    static constexpr std::size_t index_of = type_list_index_v<std::remove_const_t<Type>, type_list<typename Get::element_type..., typename Exclude::element_type...>>;
+    static constexpr std::size_t index_of = type_list_index_v<stl::remove_const_t<Type>, type_list<typename Get::element_type..., typename Exclude::element_type...>>;
 
     template<std::size_t Curr, std::size_t Other, typename... Args>
     [[nodiscard]] auto dispatch_get(const stl::tuple<typename base_type::entity_type, Args...> &curr) const {
@@ -958,7 +958,7 @@ public:
      */
     template<typename Type = Get::element_type>
     [[nodiscard]] auto *storage() const noexcept {
-        static_assert(stl::is_same_v<std::remove_const_t<Type>, typename Get::element_type>, "Invalid element type");
+        static_assert(stl::is_same_v<stl::remove_const_t<Type>, typename Get::element_type>, "Invalid element type");
         return storage<0>();
     }
 
@@ -1017,7 +1017,7 @@ public:
      */
     template<typename Elem>
     [[nodiscard]] decltype(auto) get(const entity_type entt) const {
-        static_assert(stl::is_same_v<std::remove_const_t<Elem>, typename Get::element_type>, "Invalid element type");
+        static_assert(stl::is_same_v<stl::remove_const_t<Elem>, typename Get::element_type>, "Invalid element type");
         return get<0>(entt);
     }
 

src/entt/meta/meta.hpp

@@ -69,13 +69,13 @@ public:
           data{&instance},
           value_type_node{&internal::resolve<typename Type::value_type>},
           const_reference_node{&internal::resolve<stl::remove_cvref_t<typename Type::const_reference>>},
-          size_fn{meta_sequence_container_traits<std::remove_const_t<Type>>::size},
-          clear_fn{meta_sequence_container_traits<std::remove_const_t<Type>>::clear},
-          reserve_fn{meta_sequence_container_traits<std::remove_const_t<Type>>::reserve},
-          resize_fn{meta_sequence_container_traits<std::remove_const_t<Type>>::resize},
-          begin_end_fn{meta_sequence_container_traits<std::remove_const_t<Type>>::iter},
-          insert_fn{meta_sequence_container_traits<std::remove_const_t<Type>>::insert},
-          erase_fn{meta_sequence_container_traits<std::remove_const_t<Type>>::erase},
+          size_fn{meta_sequence_container_traits<stl::remove_const_t<Type>>::size},
+          clear_fn{meta_sequence_container_traits<stl::remove_const_t<Type>>::clear},
+          reserve_fn{meta_sequence_container_traits<stl::remove_const_t<Type>>::reserve},
+          resize_fn{meta_sequence_container_traits<stl::remove_const_t<Type>>::resize},
+          begin_end_fn{meta_sequence_container_traits<stl::remove_const_t<Type>>::iter},
+          insert_fn{meta_sequence_container_traits<stl::remove_const_t<Type>>::insert},
+          erase_fn{meta_sequence_container_traits<stl::remove_const_t<Type>>::erase},
           const_only{std::is_const_v<Type>} {}
 
     [[nodiscard]] inline meta_type value_type() const noexcept;
@@ -130,15 +130,15 @@ public:
           data{&instance},
           key_type_node{&internal::resolve<typename Type::key_type>},
           value_type_node{&internal::resolve<typename Type::value_type>},
-          size_fn{&meta_associative_container_traits<std::remove_const_t<Type>>::size},
-          clear_fn{&meta_associative_container_traits<std::remove_const_t<Type>>::clear},
-          reserve_fn{&meta_associative_container_traits<std::remove_const_t<Type>>::reserve},
-          begin_end_fn{&meta_associative_container_traits<std::remove_const_t<Type>>::iter},
-          insert_fn{&meta_associative_container_traits<std::remove_const_t<Type>>::insert},
-          erase_fn{&meta_associative_container_traits<std::remove_const_t<Type>>::erase},
-          find_fn{&meta_associative_container_traits<std::remove_const_t<Type>>::find},
+          size_fn{&meta_associative_container_traits<stl::remove_const_t<Type>>::size},
+          clear_fn{&meta_associative_container_traits<stl::remove_const_t<Type>>::clear},
+          reserve_fn{&meta_associative_container_traits<stl::remove_const_t<Type>>::reserve},
+          begin_end_fn{&meta_associative_container_traits<stl::remove_const_t<Type>>::iter},
+          insert_fn{&meta_associative_container_traits<stl::remove_const_t<Type>>::insert},
+          erase_fn{&meta_associative_container_traits<stl::remove_const_t<Type>>::erase},
+          find_fn{&meta_associative_container_traits<stl::remove_const_t<Type>>::find},
           const_only{std::is_const_v<Type>} {
-        if constexpr(!meta_associative_container_traits<std::remove_const_t<Type>>::key_only) {
+        if constexpr(!meta_associative_container_traits<stl::remove_const_t<Type>>::key_only) {
             mapped_type_node = &internal::resolve<typename Type::mapped_type>;
         }
     }
@@ -184,7 +184,7 @@ class meta_any {
 
         if constexpr(is_meta_pointer_like_v<Type>) {
             if(req == internal::meta_traits::is_pointer) {
-                if constexpr(!stl::is_void_v<std::remove_const_t<typename std::pointer_traits<Type>::element_type>>) {
+                if constexpr(!stl::is_void_v<stl::remove_const_t<typename std::pointer_traits<Type>::element_type>>) {
                     if constexpr(std::is_constructible_v<bool, Type>) {
                         if(const auto &pointer_like = any_cast<const Type &>(value.storage); pointer_like) {
                             static_cast<meta_any *>(other)->emplace<decltype(adl_meta_pointer_like<Type>::dereference(stl::declval<const Type &>()))>(adl_meta_pointer_like<Type>::dereference(pointer_like));
@@ -200,9 +200,9 @@ class meta_any {
                     if(const auto &elem = any_cast<const Type &>(value.storage); elem) {
                         return (value.storage.policy() == any_policy::cref) ? static_cast<meta_any *>(other)->emplace<decltype(*elem)>(*elem) : static_cast<meta_any *>(other)->emplace<decltype(*const_cast<Type &>(elem))>(*const_cast<Type &>(elem));
                     }
-                } else if constexpr(!std::is_array_v<Type> && !stl::is_void_v<std::remove_const_t<stl::remove_pointer_t<Type>>>) {
+                } else if constexpr(!std::is_array_v<Type> && !stl::is_void_v<stl::remove_const_t<stl::remove_pointer_t<Type>>>) {
                     if(auto *pointer = any_cast<Type>(value.storage); pointer) {
-                        static_cast<meta_any *>(other)->emplace<std::conditional_t<std::is_function_v<std::remove_const_t<stl::remove_pointer_t<Type>>>, Type, stl::remove_pointer_t<Type> &>>(*pointer);
+                        static_cast<meta_any *>(other)->emplace<std::conditional_t<std::is_function_v<stl::remove_const_t<stl::remove_pointer_t<Type>>>, Type, stl::remove_pointer_t<Type> &>>(*pointer);
                     }
                 }
             }
@@ -443,13 +443,13 @@ public:
     template<typename Type>
     [[nodiscard]] const Type *try_cast() const {
         const auto *elem = any_cast<const Type>(&storage);
-        return ((elem != nullptr) || !*this) ? elem : static_cast<const Type *>(internal::try_cast(internal::meta_context::from(*ctx), fetch_node(), type_hash<std::remove_const_t<Type>>::value(), storage.data()));
+        return ((elem != nullptr) || !*this) ? elem : static_cast<const Type *>(internal::try_cast(internal::meta_context::from(*ctx), fetch_node(), type_hash<stl::remove_const_t<Type>>::value(), storage.data()));
     }
 
     /*! @copydoc try_cast */
     template<typename Type>
     [[nodiscard]] Type *try_cast() {
-        return ((storage.policy() == any_policy::cref) && !std::is_const_v<Type>) ? nullptr : const_cast<Type *>(stl::as_const(*this).try_cast<std::remove_const_t<Type>>());
+        return ((storage.policy() == any_policy::cref) && !std::is_const_v<Type>) ? nullptr : const_cast<Type *>(stl::as_const(*this).try_cast<stl::remove_const_t<Type>>());
     }
 
     /**
@@ -458,7 +458,7 @@ public:
      * @return A reference to the contained instance.
      */
     template<typename Type>
-    [[nodiscard]] std::remove_const_t<Type> cast() const {
+    [[nodiscard]] stl::remove_const_t<Type> cast() const {
         auto *const instance = try_cast<stl::remove_reference_t<Type>>();
         ENTT_ASSERT(instance, "Invalid instance");
         return static_cast<Type>(*instance);
@@ -466,7 +466,7 @@ public:
 
     /*! @copydoc cast */
     template<typename Type>
-    [[nodiscard]] std::remove_const_t<Type> cast() {
+    [[nodiscard]] stl::remove_const_t<Type> cast() {
         // forces const on non-reference types to make them work also with wrappers for const references
         auto *const instance = try_cast<stl::remove_reference_t<const Type>>();
         ENTT_ASSERT(instance, "Invalid instance");
@@ -789,7 +789,7 @@ struct meta_custom {
      */
     template<typename Type>
     [[nodiscard]] operator Type *() const noexcept {
-        return ((node != nullptr) && (type_hash<std::remove_const_t<Type>>::value() == node->id)) ? static_cast<Type *>(node->value.get()) : nullptr;
+        return ((node != nullptr) && (type_hash<stl::remove_const_t<Type>>::value() == node->id)) ? static_cast<Type *>(node->value.get()) : nullptr;
     }
 
     /**

src/entt/meta/node.hpp

@@ -226,7 +226,7 @@ auto setup_node_for() noexcept {
             | (is_complete_v<meta_sequence_container_traits<Type>> ? meta_traits::is_sequence_container : meta_traits::is_none)
             | (is_complete_v<meta_associative_container_traits<Type>> ? meta_traits::is_associative_container : meta_traits::is_none),
         size_of_v<Type>,
-        &resolve<std::remove_const_t<stl::remove_pointer_t<Type>>>};
+        &resolve<stl::remove_const_t<stl::remove_pointer_t<Type>>>};
 
     if constexpr(std::is_default_constructible_v<Type>) {
         node.default_constructor = +[](const meta_ctx &ctx) {

src/entt/poly/poly.hpp

@@ -50,7 +50,7 @@ class poly_vtable {
     using inspector = Concept::template type<poly_inspector>;
 
     template<typename Ret, typename Clazz, typename... Args>
-    requires std::derived_from<inspector, std::remove_const_t<Clazz>>
+    requires std::derived_from<inspector, stl::remove_const_t<Clazz>>
     static auto vtable_entry(Ret (*)(Clazz &, Args...))
         -> Ret (*)(constness_as_t<basic_any<Len, Align>, Clazz> &, Args...);
 

src/entt/resource/cache.hpp

@@ -44,7 +44,7 @@ public:
 
     template<typename Other>
     requires (!std::same_as<It, Other> && std::constructible_from<It, Other>)
-    constexpr resource_cache_iterator(const resource_cache_iterator<std::remove_const_t<Type>, Other> &other) noexcept
+    constexpr resource_cache_iterator(const resource_cache_iterator<stl::remove_const_t<Type>, Other> &other) noexcept
         : it{other.it} {}
 
     constexpr resource_cache_iterator &operator++() noexcept {

src/entt/signal/delegate.hpp

@@ -65,7 +65,7 @@ class delegate;
  */
 template<typename Ret, typename... Args>
 class delegate<Ret(Args...)> {
-    using return_type = std::remove_const_t<Ret>;
+    using return_type = stl::remove_const_t<Ret>;
     using delegate_type = return_type(const void *, Args...);
 
     template<auto Candidate, std::size_t... Index>

src/entt/stl/type_traits.hpp

@@ -15,6 +15,7 @@ using std::is_pointer_v;
 using std::is_same_v;
 using std::is_trivially_destructible_v;
 using std::is_void_v;
+using std::remove_const_t;
 using std::remove_cvref_t;
 using std::remove_pointer_t;
 using std::remove_reference_t;