stl: std::get

src/entt/container/table.hpp

@@ -37,10 +37,10 @@ public:
     template<typename... Other>
     requires (std::constructible_from<It, Other> && ...)
     constexpr table_iterator(const table_iterator<Other...> &other) noexcept
-        : table_iterator{std::get<Other>(other.it)...} {}
+        : table_iterator{stl::get<Other>(other.it)...} {}
 
     constexpr table_iterator &operator++() noexcept {
-        return (++std::get<It>(it), ...), *this;
+        return (++stl::get<It>(it), ...), *this;
     }
 
     constexpr table_iterator operator++(int) noexcept {
@@ -49,7 +49,7 @@ public:
     }
 
     constexpr table_iterator &operator--() noexcept {
-        return (--std::get<It>(it), ...), *this;
+        return (--stl::get<It>(it), ...), *this;
     }
 
     constexpr table_iterator operator--(int) noexcept {
@@ -58,7 +58,7 @@ public:
     }
 
     constexpr table_iterator &operator+=(const difference_type value) noexcept {
-        return ((std::get<It>(it) += value), ...), *this;
+        return ((stl::get<It>(it) += value), ...), *this;
     }
 
     constexpr table_iterator operator+(const difference_type value) const noexcept {
@@ -75,7 +75,7 @@ public:
     }
 
     [[nodiscard]] constexpr reference operator[](const difference_type value) const noexcept {
-        return stl::forward_as_tuple(std::get<It>(it)[value]...);
+        return stl::forward_as_tuple(stl::get<It>(it)[value]...);
     }
 
     [[nodiscard]] constexpr pointer operator->() const noexcept {
@@ -88,17 +88,17 @@ public:
 
     template<typename... Other>
     [[nodiscard]] constexpr stl::ptrdiff_t operator-(const table_iterator<Other...> &other) const noexcept {
-        return std::get<0>(it) - std::get<0>(other.it);
+        return stl::get<0>(it) - stl::get<0>(other.it);
     }
 
     template<typename... Other>
     [[nodiscard]] constexpr bool operator==(const table_iterator<Other...> &other) const noexcept {
-        return std::get<0>(it) == std::get<0>(other.it);
+        return stl::get<0>(it) == stl::get<0>(other.it);
     }
 
     template<typename... Other>
     [[nodiscard]] constexpr auto operator<=>(const table_iterator<Other...> &other) const noexcept {
-        return std::get<0>(it) <=> std::get<0>(other.it);
+        return stl::get<0>(it) <=> stl::get<0>(other.it);
     }
 
 private:
@@ -146,7 +146,7 @@ public:
      */
     explicit basic_table(const Container &...container) noexcept
         : payload{container...} {
-        ENTT_ASSERT((((std::get<Container>(payload).size() * sizeof...(Container)) == (std::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
+        ENTT_ASSERT((((stl::get<Container>(payload).size() * sizeof...(Container)) == (stl::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
     }
 
     /**
@@ -155,7 +155,7 @@ public:
      */
     explicit basic_table(Container &&...container) noexcept
         : payload{stl::move(container)...} {
-        ENTT_ASSERT((((std::get<Container>(payload).size() * sizeof...(Container)) == (std::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
+        ENTT_ASSERT((((stl::get<Container>(payload).size() * sizeof...(Container)) == (stl::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
     }
 
     /*! @brief Default copy constructor, deleted on purpose. */
@@ -184,7 +184,7 @@ public:
     template<class Allocator>
     basic_table(const Container &...container, const Allocator &allocator) noexcept
         : payload{Container{container, allocator}...} {
-        ENTT_ASSERT((((std::get<Container>(payload).size() * sizeof...(Container)) == (std::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
+        ENTT_ASSERT((((stl::get<Container>(payload).size() * sizeof...(Container)) == (stl::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
     }
 
     /**
@@ -196,7 +196,7 @@ public:
     template<class Allocator>
     basic_table(Container &&...container, const Allocator &allocator) noexcept
         : payload{Container{stl::move(container), allocator}...} {
-        ENTT_ASSERT((((std::get<Container>(payload).size() * sizeof...(Container)) == (std::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
+        ENTT_ASSERT((((stl::get<Container>(payload).size() * sizeof...(Container)) == (stl::get<Container>(payload).size() + ...)) && ...), "Unexpected container size");
     }
 
     /**
@@ -207,7 +207,7 @@ public:
      */
     template<class Allocator>
     basic_table(basic_table &&other, const Allocator &allocator)
-        : payload{Container{stl::move(std::get<Container>(other.payload)), allocator}...} {}
+        : payload{Container{stl::move(stl::get<Container>(other.payload)), allocator}...} {}
 
     /*! @brief Default destructor. */
     ~basic_table() = default;
@@ -246,7 +246,7 @@ public:
      * @param cap Desired capacity.
      */
     void reserve(const size_type cap) {
-        (std::get<Container>(payload).reserve(cap), ...);
+        (stl::get<Container>(payload).reserve(cap), ...);
     }
 
     /**
@@ -255,12 +255,12 @@ public:
      * @return Capacity of the table.
      */
     [[nodiscard]] size_type capacity() const noexcept {
-        return std::get<0>(payload).capacity();
+        return stl::get<0>(payload).capacity();
     }
 
     /*! @brief Requests the removal of unused capacity. */
     void shrink_to_fit() {
-        (std::get<Container>(payload).shrink_to_fit(), ...);
+        (stl::get<Container>(payload).shrink_to_fit(), ...);
     }
 
     /**
@@ -268,7 +268,7 @@ public:
      * @return Number of rows.
      */
     [[nodiscard]] size_type size() const noexcept {
-        return std::get<0>(payload).size();
+        return stl::get<0>(payload).size();
     }
 
     /**
@@ -276,7 +276,7 @@ public:
      * @return True if the table is empty, false otherwise.
      */
     [[nodiscard]] bool empty() const noexcept {
-        return std::get<0>(payload).empty();
+        return stl::get<0>(payload).empty();
     }
 
     /**
@@ -287,7 +287,7 @@ public:
      * @return An iterator to the first row of the table.
      */
     [[nodiscard]] const_iterator cbegin() const noexcept {
-        return {std::get<Container>(payload).cbegin()...};
+        return {stl::get<Container>(payload).cbegin()...};
     }
 
     /*! @copydoc cbegin */
@@ -297,7 +297,7 @@ public:
 
     /*! @copydoc begin */
     [[nodiscard]] iterator begin() noexcept {
-        return {std::get<Container>(payload).begin()...};
+        return {stl::get<Container>(payload).begin()...};
     }
 
     /**
@@ -305,7 +305,7 @@ public:
      * @return An iterator to the element following the last row of the table.
      */
     [[nodiscard]] const_iterator cend() const noexcept {
-        return {std::get<Container>(payload).cend()...};
+        return {stl::get<Container>(payload).cend()...};
     }
 
     /*! @copydoc cend */
@@ -315,7 +315,7 @@ public:
 
     /*! @copydoc end */
     [[nodiscard]] iterator end() noexcept {
-        return {std::get<Container>(payload).end()...};
+        return {stl::get<Container>(payload).end()...};
     }
 
     /**
@@ -326,7 +326,7 @@ public:
      * @return An iterator to the first row of the reversed table.
      */
     [[nodiscard]] const_reverse_iterator crbegin() const noexcept {
-        return {std::get<Container>(payload).crbegin()...};
+        return {stl::get<Container>(payload).crbegin()...};
     }
 
     /*! @copydoc crbegin */
@@ -336,7 +336,7 @@ public:
 
     /*! @copydoc rbegin */
     [[nodiscard]] reverse_iterator rbegin() noexcept {
-        return {std::get<Container>(payload).rbegin()...};
+        return {stl::get<Container>(payload).rbegin()...};
     }
 
     /**
@@ -345,7 +345,7 @@ public:
      * table.
      */
     [[nodiscard]] const_reverse_iterator crend() const noexcept {
-        return {std::get<Container>(payload).crend()...};
+        return {stl::get<Container>(payload).crend()...};
     }
 
     /*! @copydoc crend */
@@ -355,7 +355,7 @@ public:
 
     /*! @copydoc rend */
     [[nodiscard]] reverse_iterator rend() noexcept {
-        return {std::get<Container>(payload).rend()...};
+        return {stl::get<Container>(payload).rend()...};
     }
 
     /**
@@ -367,9 +367,9 @@ public:
     template<typename... Args>
     stl::tuple<typename Container::value_type &...> emplace(Args &&...args) {
         if constexpr(sizeof...(Args) == 0u) {
-            return stl::forward_as_tuple(std::get<Container>(payload).emplace_back()...);
+            return stl::forward_as_tuple(stl::get<Container>(payload).emplace_back()...);
         } else {
-            return stl::forward_as_tuple(std::get<Container>(payload).emplace_back(stl::forward<Args>(args))...);
+            return stl::forward_as_tuple(stl::get<Container>(payload).emplace_back(stl::forward<Args>(args))...);
         }
     }
 
@@ -380,7 +380,7 @@ public:
      */
     iterator erase(const_iterator pos) {
         const auto diff = pos - begin();
-        return {std::get<Container>(payload).erase(std::get<Container>(payload).begin() + diff)...};
+        return {stl::get<Container>(payload).erase(stl::get<Container>(payload).begin() + diff)...};
     }
 
     /**
@@ -399,18 +399,18 @@ public:
      */
     [[nodiscard]] stl::tuple<const typename Container::value_type &...> operator[](const size_type pos) const {
         ENTT_ASSERT(pos < size(), "Index out of bounds");
-        return stl::forward_as_tuple(std::get<Container>(payload)[pos]...);
+        return stl::forward_as_tuple(stl::get<Container>(payload)[pos]...);
     }
 
     /*! @copydoc operator[] */
     [[nodiscard]] stl::tuple<typename Container::value_type &...> operator[](const size_type pos) {
         ENTT_ASSERT(pos < size(), "Index out of bounds");
-        return stl::forward_as_tuple(std::get<Container>(payload)[pos]...);
+        return stl::forward_as_tuple(stl::get<Container>(payload)[pos]...);
     }
 
     /*! @brief Clears a table. */
     void clear() {
-        (std::get<Container>(payload).clear(), ...);
+        (stl::get<Container>(payload).clear(), ...);
     }
 
 private:

src/entt/core/compressed_pair.hpp

@@ -30,7 +30,7 @@ struct compressed_pair_element {
 
     template<typename... Args, stl::size_t... Index>
     constexpr compressed_pair_element(stl::tuple<Args...> args, stl::index_sequence<Index...>) noexcept(stl::is_nothrow_constructible_v<Type, Args...>)
-        : value{stl::forward<Args>(std::get<Index>(args))...} {}
+        : value{stl::forward<Args>(stl::get<Index>(args))...} {}
 
     [[nodiscard]] constexpr reference get() noexcept {
         return value;
@@ -62,7 +62,7 @@ struct compressed_pair_element<Type, Tag>: Type {
 
     template<typename... Args, stl::size_t... Index>
     constexpr compressed_pair_element(stl::tuple<Args...> args, stl::index_sequence<Index...>) noexcept(stl::is_nothrow_constructible_v<base_type, Args...>)
-        : base_type{stl::forward<Args>(std::get<Index>(args))...} {}
+        : base_type{stl::forward<Args>(stl::get<Index>(args))...} {}
 
     [[nodiscard]] constexpr reference get() noexcept {
         return *this;

src/entt/core/tuple.hpp

@@ -39,7 +39,7 @@ inline constexpr bool is_tuple_v = is_tuple<Type>::value;
 template<typename Type>
 constexpr decltype(auto) unwrap_tuple(Type &&value) noexcept {
     if constexpr(stl::tuple_size_v<stl::remove_reference_t<Type>> == 1u) {
-        return std::get<0>(stl::forward<Type>(value));
+        return stl::get<0>(stl::forward<Type>(value));
     } else {
         return stl::forward<Type>(value);
     }

src/entt/entity/group.hpp

@@ -63,7 +63,7 @@ public:
     }
 
     [[nodiscard]] reference operator*() const noexcept {
-        return stl::tuple_cat(stl::make_tuple(*it), index_to_element(*std::get<Owned *>(pools))..., std::get<Get *>(pools)->get_as_tuple(*it)...);
+        return stl::tuple_cat(stl::make_tuple(*it), index_to_element(*stl::get<Owned *>(pools))..., stl::get<Get *>(pools)->get_as_tuple(*it)...);
     }
 
     [[nodiscard]] pointer operator->() const noexcept {
@@ -505,9 +505,9 @@ public:
         if constexpr(sizeof...(Index) == 0) {
             return stl::apply([entt](auto *...curr) { return stl::tuple_cat(curr->get_as_tuple(entt)...); }, cpools);
         } else if constexpr(sizeof...(Index) == 1) {
-            return (std::get<Index>(cpools)->get(entt), ...);
+            return (stl::get<Index>(cpools)->get(entt), ...);
         } else {
-            return stl::tuple_cat(std::get<Index>(cpools)->get_as_tuple(entt)...);
+            return stl::tuple_cat(stl::get<Index>(cpools)->get_as_tuple(entt)...);
         }
     }
 
@@ -622,9 +622,9 @@ public:
             } else {
                 auto comp = [&compare, cpools = pools_for(stl::index_sequence_for<Get...>{})](const entity_type lhs, const entity_type rhs) {
                     if constexpr(sizeof...(Index) == 1) {
-                        return compare((std::get<Index>(cpools)->get(lhs), ...), (std::get<Index>(cpools)->get(rhs), ...));
+                        return compare((stl::get<Index>(cpools)->get(lhs), ...), (stl::get<Index>(cpools)->get(rhs), ...));
                     } else {
-                        return compare(stl::forward_as_tuple(std::get<Index>(cpools)->get(lhs)...), stl::forward_as_tuple(std::get<Index>(cpools)->get(rhs)...));
+                        return compare(stl::forward_as_tuple(stl::get<Index>(cpools)->get(lhs)...), stl::forward_as_tuple(stl::get<Index>(cpools)->get(rhs)...));
                     }
                 };
 
@@ -904,9 +904,9 @@ public:
         if constexpr(sizeof...(Index) == 0) {
             return stl::apply([entt](auto *...curr) { return stl::tuple_cat(curr->get_as_tuple(entt)...); }, cpools);
         } else if constexpr(sizeof...(Index) == 1) {
-            return (std::get<Index>(cpools)->get(entt), ...);
+            return (stl::get<Index>(cpools)->get(entt), ...);
         } else {
-            return stl::tuple_cat(std::get<Index>(cpools)->get_as_tuple(entt)...);
+            return stl::tuple_cat(stl::get<Index>(cpools)->get_as_tuple(entt)...);
         }
     }
 
@@ -1023,9 +1023,9 @@ public:
         } else {
             auto comp = [&compare, &cpools](const entity_type lhs, const entity_type rhs) {
                 if constexpr(sizeof...(Index) == 1) {
-                    return compare((std::get<Index>(cpools)->get(lhs), ...), (std::get<Index>(cpools)->get(rhs), ...));
+                    return compare((stl::get<Index>(cpools)->get(lhs), ...), (stl::get<Index>(cpools)->get(rhs), ...));
                 } else {
-                    return compare(stl::forward_as_tuple(std::get<Index>(cpools)->get(lhs)...), stl::forward_as_tuple(std::get<Index>(cpools)->get(rhs)...));
+                    return compare(stl::forward_as_tuple(stl::get<Index>(cpools)->get(lhs)...), stl::forward_as_tuple(stl::get<Index>(cpools)->get(rhs)...));
                 }
             };
 

src/entt/entity/storage.hpp

@@ -158,7 +158,7 @@ public:
         : it{other.it} {}
 
     constexpr extended_storage_iterator &operator++() noexcept {
-        return ++std::get<It>(it), (++std::get<Other>(it), ...), *this;
+        return ++stl::get<It>(it), (++stl::get<Other>(it), ...), *this;
     }
 
     constexpr extended_storage_iterator operator++(int) noexcept {
@@ -171,16 +171,16 @@ public:
     }
 
     [[nodiscard]] constexpr reference operator*() const noexcept {
-        return {*std::get<It>(it), *std::get<Other>(it)...};
+        return {*stl::get<It>(it), *stl::get<Other>(it)...};
     }
 
     [[nodiscard]] constexpr iterator_type base() const noexcept {
-        return std::get<It>(it);
+        return stl::get<It>(it);
     }
 
     template<typename... Args>
     [[nodiscard]] constexpr bool operator==(const extended_storage_iterator<Args...> &other) const noexcept {
-        return std::get<0>(it) == std::get<0>(other.it);
+        return stl::get<0>(it) == stl::get<0>(other.it);
     }
 
 private:

src/entt/entity/view.hpp

@@ -155,7 +155,7 @@ struct extended_view_iterator final {
 
     [[nodiscard]] reference operator*() const noexcept {
         return [this]<auto... Index>(stl::index_sequence<Index...>) {
-            return stl::tuple_cat(stl::make_tuple(*it), static_cast<Get *>(const_cast<constness_as_t<typename Get::base_type, Get> *>(std::get<Index>(it.pools)))->get_as_tuple(*it)...);
+            return stl::tuple_cat(stl::make_tuple(*it), static_cast<Get *>(const_cast<constness_as_t<typename Get::base_type, Get> *>(stl::get<Index>(it.pools)))->get_as_tuple(*it)...);
         }(stl::index_sequence_for<Get...>{});
     }
 
@@ -420,16 +420,16 @@ class basic_view<get_t<Get...>, exclude_t<Exclude...>>
     template<stl::size_t Curr, stl::size_t Other, typename... Args>
     [[nodiscard]] auto dispatch_get(const stl::tuple<typename base_type::entity_type, Args...> &curr) const {
         if constexpr(Curr == Other) {
-            return stl::forward_as_tuple(std::get<Args>(curr)...);
+            return stl::forward_as_tuple(stl::get<Args>(curr)...);
         } else {
-            return storage<Other>()->get_as_tuple(std::get<0>(curr));
+            return storage<Other>()->get_as_tuple(stl::get<0>(curr));
         }
     }
 
     template<stl::size_t Curr, typename Func, stl::size_t... Index>
     void each(Func func, stl::index_sequence<Index...>) const {
         for(const auto curr: storage<Curr>()->each()) {
-            if(const auto entt = std::get<0>(curr); (!internal::tombstone_check_v<Get...> || (entt != tombstone)) && ((Curr == Index || base_type::pool_at(Index)->contains(entt)) && ...) && base_type::none_of(entt)) {
+            if(const auto entt = stl::get<0>(curr); (!internal::tombstone_check_v<Get...> || (entt != tombstone)) && ((Curr == Index || base_type::pool_at(Index)->contains(entt)) && ...) && base_type::none_of(entt)) {
                 if constexpr(is_applicable_v<Func, decltype(stl::tuple_cat(stl::tuple<entity_type>{}, stl::declval<basic_view>().get({})))>) {
                     stl::apply(func, stl::tuple_cat(stl::make_tuple(entt), dispatch_get<Curr, Index>(curr)...));
                 } else {
@@ -937,7 +937,7 @@ public:
      * @param value The storage for the type to iterate.
      */
     basic_view(stl::tuple<Get &> value, stl::tuple<> = {}) noexcept
-        : basic_view{std::get<0>(value)} {}
+        : basic_view{stl::get<0>(value)} {}
 
     /**
      * @brief Constructs a view from a convertible counterpart.

src/entt/poly/poly.hpp

@@ -97,7 +97,7 @@ class poly_vtable {
     template<typename Type, auto... Index>
     [[nodiscard]] static auto fill_vtable(stl::index_sequence<Index...>) noexcept {
         vtable_type impl{};
-        (fill_vtable_entry<Type, value_list_element_v<Index, typename Concept::template impl<Type>>>(std::get<Index>(impl)), ...);
+        (fill_vtable_entry<Type, value_list_element_v<Index, typename Concept::template impl<Type>>>(stl::get<Index>(impl)), ...);
         return impl;
     }
 
@@ -118,7 +118,7 @@ public:
         static const vtable_type vtable = fill_vtable<Type>(stl::make_index_sequence<Concept::template impl<Type>::size>{});
 
         if constexpr(is_mono) {
-            return std::get<0>(vtable);
+            return stl::get<0>(vtable);
         } else {
             return &vtable;
         }
@@ -146,7 +146,7 @@ struct poly_base {
         if constexpr(stl::is_function_v<stl::remove_pointer_t<decltype(poly.vtable)>>) {
             return poly.vtable(poly.storage, stl::forward<Args>(args)...);
         } else {
-            return std::get<Member>(*poly.vtable)(poly.storage, stl::forward<Args>(args)...);
+            return stl::get<Member>(*poly.vtable)(poly.storage, stl::forward<Args>(args)...);
         }
     }
 
@@ -159,7 +159,7 @@ struct poly_base {
             static_assert(Member == 0u, "Unknown member");
             return poly.vtable(poly.storage, stl::forward<Args>(args)...);
         } else {
-            return std::get<Member>(*poly.vtable)(poly.storage, stl::forward<Args>(args)...);
+            return stl::get<Member>(*poly.vtable)(poly.storage, stl::forward<Args>(args)...);
         }
     }
 };

src/entt/signal/delegate.hpp

@@ -73,7 +73,7 @@ class delegate<Ret(Args...)> {
         return [](const void *, Args... args) -> return_type {
             [[maybe_unused]] const auto arguments = stl::forward_as_tuple(stl::forward<Args>(args)...);
             [[maybe_unused]] constexpr auto offset = !stl::is_invocable_r_v<Ret, decltype(Candidate), type_list_element_t<Index, type_list<Args...>>...> * (sizeof...(Args) - sizeof...(Index));
-            return static_cast<Ret>(std::invoke(Candidate, stl::forward<type_list_element_t<Index + offset, type_list<Args...>>>(std::get<Index + offset>(arguments))...));
+            return static_cast<Ret>(std::invoke(Candidate, stl::forward<type_list_element_t<Index + offset, type_list<Args...>>>(stl::get<Index + offset>(arguments))...));
         };
     }
 
@@ -83,7 +83,7 @@ class delegate<Ret(Args...)> {
             Type *curr = static_cast<Type *>(const_cast<constness_as_t<void, Type> *>(payload));
             [[maybe_unused]] const auto arguments = stl::forward_as_tuple(stl::forward<Args>(args)...);
             [[maybe_unused]] constexpr auto offset = !stl::is_invocable_r_v<Ret, decltype(Candidate), Type &, type_list_element_t<Index, type_list<Args...>>...> * (sizeof...(Args) - sizeof...(Index));
-            return static_cast<Ret>(std::invoke(Candidate, *curr, stl::forward<type_list_element_t<Index + offset, type_list<Args...>>>(std::get<Index + offset>(arguments))...));
+            return static_cast<Ret>(std::invoke(Candidate, *curr, stl::forward<type_list_element_t<Index + offset, type_list<Args...>>>(stl::get<Index + offset>(arguments))...));
         };
     }
 
@@ -93,7 +93,7 @@ class delegate<Ret(Args...)> {
             Type *curr = static_cast<Type *>(const_cast<constness_as_t<void, Type> *>(payload));
             [[maybe_unused]] const auto arguments = stl::forward_as_tuple(stl::forward<Args>(args)...);
             [[maybe_unused]] constexpr auto offset = !stl::is_invocable_r_v<Ret, decltype(Candidate), Type *, type_list_element_t<Index, type_list<Args...>>...> * (sizeof...(Args) - sizeof...(Index));
-            return static_cast<Ret>(std::invoke(Candidate, curr, stl::forward<type_list_element_t<Index + offset, type_list<Args...>>>(std::get<Index + offset>(arguments))...));
+            return static_cast<Ret>(std::invoke(Candidate, curr, stl::forward<type_list_element_t<Index + offset, type_list<Args...>>>(stl::get<Index + offset>(arguments))...));
         };
     }
 

src/entt/stl/array.hpp

@@ -7,6 +7,7 @@
 namespace entt::stl {
 
 using std::array;
+using std::get;
 
 } // namespace entt::stl
 /*! @endcond */

src/entt/stl/tuple.hpp

@@ -8,6 +8,7 @@ namespace entt::stl {
 
 using std::apply;
 using std::forward_as_tuple;
+using std::get;
 using std::make_from_tuple;
 using std::make_tuple;
 using std::tuple;

src/entt/tools/davey.hpp

@@ -200,7 +200,7 @@ static void present_view(const meta_ctx &ctx, const basic_view<get_t<Get...>, ex
     const stl::array<const typename view_type::common_type *, sizeof...(Index)> range{view.template storage<Index>()...};
 
     for(auto tup: view.each()) {
-        const auto entt = std::get<0>(tup);
+        const auto entt = stl::get<0>(tup);
         ImGui::PushID(static_cast<int>(to_entity(entt)));
 
         if(ImGui::TreeNode(&type_id<typename view_type::entity_type>(), "%d [%d/%d]", to_integral(entt), to_entity(entt), to_version(entt))) {