🎨 Adjust tuple concepts

include/stdx/concepts.hpp

@@ -2,23 +2,24 @@
 
 #include <stdx/type_traits.hpp>
 
+#include <type_traits>
+
 #if __has_include(<concepts>)
 #include <concepts>
 #endif
 
 #if __cpp_lib_concepts < 202002L
 
 #include <functional>
-#include <type_traits>
 #include <utility>
 
 namespace stdx {
 inline namespace v1 {
 template <typename T>
-concept integral = std::is_integral_v<T>;
+concept floating_point = std::is_floating_point_v<T>;
 
 template <typename T>
-concept floating_point = std::is_floating_point_v<T>;
+concept integral = std::is_integral_v<T>;
 
 template <typename T>
 concept signed_integral = integral<T> and std::is_signed_v<T>;
@@ -43,16 +44,6 @@ concept same_as_helper = std::is_same_v<T, U>;
 template <typename T, typename U>
 concept same_as = detail::same_as_helper<T, U> and detail::same_as_helper<U, T>;
 
-template <typename T, typename... Us>
-constexpr auto same_any = (... or same_as<T, Us>);
-
-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<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;
-
 template <typename T>
 concept equality_comparable = requires(T const &t) {
     { t == t } -> same_as<bool>;
@@ -91,21 +82,6 @@ concept boolean_testable = boolean_testable_impl<B> and requires(B &&b) {
 template <typename F, typename... Args>
 concept predicate = invocable<F, Args...> and
                     detail::boolean_testable<std::invoke_result_t<F, Args...>>;
-
-template <typename T>
-concept callable = is_callable_v<T>;
-
-template <typename T, template <typename> typename TypeTrait>
-concept has_trait = TypeTrait<T>::value;
-
-template <typename T>
-concept structural = is_structural_v<T>;
-
-template <typename T>
-concept complete = is_complete_v<T>;
-
-template <typename T, typename U>
-concept same_template_as = is_same_template_v<T, U>;
 } // namespace v1
 } // namespace stdx
 
@@ -130,17 +106,30 @@ using std::totally_ordered;
 
 using std::invocable;
 using std::predicate;
+} // namespace v1
+} // namespace stdx
 
-template <typename T>
-concept callable = is_callable_v<T>;
+#endif
 
-template <typename T, template <typename> typename TypeTrait>
-concept has_trait = TypeTrait<T>::value;
+namespace stdx {
+inline namespace v1 {
 
 template <typename T, typename U>
 concept same_as_unqualified =
     same_as<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;
 
+template <typename T, typename... Us>
+constexpr auto same_any = (... or same_as<T, Us>);
+
+template <typename T, typename... Us>
+constexpr auto same_none = not same_any<T, Us...>;
+
+template <typename T>
+concept callable = is_callable_v<T>;
+
+template <typename T, template <typename> typename TypeTrait>
+concept has_trait = TypeTrait<T>::value;
+
 template <typename T>
 concept structural = is_structural_v<T>;
 
@@ -150,12 +139,44 @@ concept complete = is_complete_v<T>;
 template <typename T, typename U>
 concept same_template_as = is_same_template_v<T, U>;
 
-template <typename T, typename... Us>
-constexpr auto same_any = (... or same_as<T, Us>);
+template <typename T>
+concept tuple_comparable = requires { typename T::common_tuple_comparable; };
+
+template <typename T>
+concept tuplelike = requires { typename std::remove_cvref_t<T>::is_tuple; };
+
+namespace detail {
+template <typename T>
+concept has_vacuous_tuple_protocol = requires {
+    {
+        tuple_size_v<std::remove_cvref_t<T>>
+    } -> std::same_as<std::size_t const &>;
+};
+template <typename T>
+concept is_vacuous_tuple = tuple_size_v<std::remove_cvref_t<T>> == 0;
+
+constexpr inline auto concept_try_get = [](auto &x) -> decltype(auto) {
+    using std::get;
+    return get<0>(x);
+};
+
+template <typename T>
+concept has_get_protocol = requires(T &t) {
+    {
+        concept_try_get(t)
+    } -> same_as_unqualified<tuple_element_t<0, std::remove_cvref_t<T>>>;
+};
+} // namespace detail
+
+template <typename T>
+concept has_tuple_protocol = detail::has_vacuous_tuple_protocol<T> and
+                             (detail::is_vacuous_tuple<T> or
+                              detail::has_get_protocol<std::remove_cvref_t<T>>);
+
+template <typename T>
+concept has_array_protocol = has_tuple_protocol<T> and requires {
+    typename std::remove_cvref_t<T>::value_type;
+};
 
-template <typename T, typename... Us>
-constexpr auto same_none = not same_any<T, Us...>;
 } // namespace v1
 } // namespace stdx
-
-#endif

include/stdx/span.hpp

@@ -281,5 +281,11 @@ constexpr auto ct_capacity_v<span<T, N>> = N;
 template <typename T>
 constexpr auto ct_capacity_v<span<T, dynamic_extent>> =
     detail::ct_capacity_fail<span<T, dynamic_extent>>{};
+
+template <std::size_t I, typename T, std::size_t N>
+struct tuple_element<I, span<T, N>> {
+    static_assert(N != dynamic_extent and I < N);
+    using type = T;
+};
 } // namespace v1
 } // namespace stdx

include/stdx/tuple.hpp

@@ -1,10 +1,10 @@
 #pragma once
 
+#include <stdx/concepts.hpp>
 #include <stdx/type_traits.hpp>
 #include <stdx/udls.hpp>
 #include <stdx/utility.hpp>
 
-#include <array>
 #include <concepts>
 #include <cstddef>
 #include <type_traits>
@@ -420,59 +420,10 @@ tuple_impl(Ts...)
     -> tuple_impl<std::index_sequence_for<Ts...>, index_function_list<>, Ts...>;
 } // namespace detail
 
-template <typename T> constexpr auto tuple_size_v = T::size();
-template <typename T, std::size_t N>
-constexpr auto tuple_size_v<std::array<T, N>> = N;
-template <typename T, typename U>
-constexpr auto tuple_size_v<std::pair<T, U>> = std::size_t{2};
-template <typename T, T N>
-constexpr auto tuple_size_v<make_integer_sequence<T, N>> = std::size_t{N};
-
-template <typename T>
-concept tuple_comparable = requires { typename T::common_tuple_comparable; };
-
-template <typename T>
-concept tuplelike = requires { typename std::remove_cvref_t<T>::is_tuple; };
-
-template <std::size_t I, typename T> struct tuple_element;
-
 template <std::size_t I, tuplelike T> struct tuple_element<I, T> {
     using type = typename T::template element_t<I>;
 };
 
-template <std::size_t I, typename T, std::size_t N>
-struct tuple_element<I, std::array<T, N>> {
-    using type = T;
-};
-
-template <std::size_t I, typename T, typename U>
-struct tuple_element<I, std::pair<T, U>> {
-    using type = nth_t<I, T, U>;
-};
-
-template <std::size_t I, typename T>
-using tuple_element_t = typename tuple_element<I, T>::type;
-
-namespace detail {
-template <typename T>
-concept has_vacuous_tuple_protocol = requires {
-    {
-        tuple_size_v<std::remove_cvref_t<T>>
-    } -> std::same_as<std::size_t const &>;
-};
-template <typename T>
-concept is_vacuous_tuple = tuple_size_v<std::remove_cvref_t<T>> == 0;
-} // namespace detail
-
-template <typename T>
-concept has_tuple_protocol =
-    detail::has_vacuous_tuple_protocol<T> and
-    (detail::is_vacuous_tuple<T> or requires(T &t) {
-        {
-            get<0>(t)
-        } -> std::same_as<tuple_element_t<0, std::remove_cvref_t<T>> &>;
-    });
-
 template <typename... Ts>
 class tuple : public detail::tuple_impl<std::index_sequence_for<Ts...>,
                                         detail::index_function_list<>, Ts...> {