Introduce static_container adaptation

`std::array` and similar types are now considered product types.
static `std::span ' is convertible to kumi::tuple.

Author: Nxirda

include/kumi/algorithm/convert.hpp

@@ -7,27 +7,8 @@
 //==================================================================================================
 #pragma once
 
-#include <span>
-
 namespace kumi
 {
-  namespace _
-  {
-    // Workaround as span has no tuple_element/tuple_size defined even if it's static
-    // as opposed to ranges::subrange for some reason
-    template<typename T> struct is_static_span : std::false_type
-    {
-    };
-
-    template<typename T, std::size_t N>
-    struct is_static_span<std::span<T, N>> : std::bool_constant<(N != std::dynamic_extent)>
-    {
-    };
-
-    template<typename T>
-    concept static_span = is_static_span<std::remove_cvref_t<T>>::value;
-  }
-
   namespace _
   {
     template<product_type Tuple, typename IndexSequence, template<typename...> class Meta = std::type_identity>
@@ -105,7 +86,7 @@ namespace kumi
   //! @param  t    kumi::product_type to convert
   //! @return An instance of kumi::tuple constructed from each elements of `t` in order.
   //!
-  //! @note An overload is provided for static std::span.
+  //! @note An overload is provided for kumi::static_container.
   //!
   //! ## Example
   //! @include doc/to_tuple.cpp
@@ -115,9 +96,11 @@ namespace kumi
     return apply([](auto&&... elems) { return tuple{elems...}; }, KUMI_FWD(t));
   }
 
-  template<_::static_span S> [[nodiscard]] KUMI_ABI constexpr auto to_tuple(S&& s)
+  template<static_container S>
+  [[nodiscard]] KUMI_ABI constexpr auto to_tuple(S&& s)
+  requires(!product_type<S>)
   {
-    constexpr auto N = std::remove_cvref_t<S>::extent;
+    constexpr auto N = container_size_v<S>;
     if constexpr (N == 0) return tuple{};
     else
       return [&]<std::size_t... I>(std::index_sequence<I...>) {

include/kumi/detail/concepts.hpp

@@ -15,20 +15,6 @@
 
 namespace kumi::_
 {
-  //==============================================================================================
-  // Helper concepts for tuple detection
-  //==============================================================================================
-  // Concept specifying a type is non-empty standard tuple-like type.
-  template<typename T>
-  concept non_empty_tuple = requires(T const& t) {
-    typename std::tuple_element<0, std::remove_cvref_t<T>>::type;
-    typename std::tuple_size<std::remove_cvref_t<T>>::type;
-  };
-
-  // Concept specifying a type is an empty standard tuple-like type.
-  template<typename T>
-  concept empty_tuple = (std::tuple_size<std::remove_cvref_t<T>>::value == 0);
-
   //==============================================================================================
   // Helper concepts for construction checks
   //==============================================================================================

include/kumi/utils/concepts.hpp

@@ -42,6 +42,15 @@ namespace kumi
   template<typename T>
   concept record_type = product_type<T> && is_record_type<std::remove_cvref_t<T>>::value;
 
+  //================================================================================================
+  //! @ingroup concepts
+  //! @brief Concept specifying a type follows the Container Type semantic
+  //!
+  //! A type `T` models `kumi::static_container` if it is an homogeneous container of fixed size.
+  //================================================================================================
+  template<typename T>
+  concept static_container = is_static_container_v<std::remove_cvref_t<T>>;
+
   //================================================================================================
   //! @ingroup concepts
   //! @brief Concept specifying a type follows the Product Type semantic and has a known size

include/kumi/utils/monoid.hpp

@@ -5,6 +5,8 @@
   SPDX-License-Identifier: BSL-1.0
 */
 //==================================================================================================
+#pragma once
+
 #include <cstddef>
 
 namespace kumi

include/kumi/utils/std.hpp

@@ -9,7 +9,6 @@
 
 #include <kumi/utils/concepts.hpp>
 #include <kumi/utils/traits.hpp>
-#include <array>
 #include <type_traits>
 #include <utility>
 
@@ -87,10 +86,6 @@ struct std::basic_common_reference<kumi::tuple<Ts...>, kumi::tuple<Us...>, TQual
 //==================================================================================================
 // Standard types support (for those that model `tuple-like` & are declared in `utility`)
 //==================================================================================================
-template<typename T, std::size_t N> struct kumi::is_product_type<std::array<T, N>> : std::true_type
-{
-};
-
 template<typename... Ts> struct kumi::is_product_type<std::tuple<Ts...>> : std::true_type
 {
 };

include/kumi/utils/traits.hpp

@@ -16,6 +16,39 @@
 
 namespace kumi
 {
+
+  namespace _
+  {
+    //==============================================================================================
+    // Helper concepts for tuple detection
+    //==============================================================================================
+    // Concept specifying a type is non-empty standard tuple-like type.
+    template<typename T>
+    concept non_empty_tuple = requires(T const& t) {
+      typename std::tuple_element<0, std::remove_cvref_t<T>>::type;
+      typename std::tuple_size<std::remove_cvref_t<T>>::type;
+    };
+
+    // Concept specifying a type is an empty standard tuple-like type.
+    template<typename T>
+    concept empty_tuple = (std::tuple_size<std::remove_cvref_t<T>>::value == 0);
+
+    //==============================================================================================
+    // Helper concepts for container detection
+    //==============================================================================================
+    // Concept specifying a type is standard container-like type.
+    template<typename T>
+    concept container_like = requires(T const& t) {
+      typename T::value_type;
+      typename T::size_type;
+
+      { t.size() } -> kumi::convertible_to<std::size_t>;
+      { t.begin() };
+      { t.end() };
+      { t.data() };
+    };
+  }
+
   //================================================================================================
   //! @ingroup traits
   //! @brief Opt-in traits for types behaving like a kumi::product_type
@@ -177,6 +210,107 @@ namespace kumi
   template<std::size_t I, typename T> using member_t = typename member<I, T>::type;
 }
 
+namespace kumi
+{
+  //================================================================================================
+  //! @ingroup traits
+  //! @brief Traits detecting types behaving like a kumi::static_container.
+  //!
+  //! To be treated like a static_container, a user defined type must expose a type and a
+  //! statically know size encoded in the type. It shall also provide general container utilities.
+  //!
+  //! @note The type shall be templated on the type and the size to be picked up.
+  //!
+  //! ## Helper value
+  //! @code
+  //!   template<typename T> inline constexpr auto is_static_container = is_static_container<T>::value;
+  //! @endcode
+  //! ## Example:
+  //==============================================================================================
+  template<typename T> struct is_static_container : std::false_type
+  {
+  };
+
+  template<template<class, std::size_t> typename Container, typename T, std::size_t N>
+  requires _::container_like<Container<T, N>> && (N != static_cast<std::size_t>(-1))
+  struct is_static_container<Container<T, N>> : std::true_type
+  {
+    using value_type = T;
+    using size = std::integral_constant<std::size_t, N>;
+  };
+
+  template<typename T> inline constexpr auto is_static_container_v = is_static_container<T>::value;
+
+  //================================================================================================
+  //! @ingroup traits
+  //! @brief Returns the number of elements of a kumi::static_container
+  //!
+  //! @tparam T kumi::static_container to inspect
+  //!
+  //! ## Helper value
+  //! @code
+  //!   template<typename T> inline constexpr auto container_size_v = container_size<T>::value;
+  //! @endcode
+  //================================================================================================
+  template<typename T> struct container_size : is_static_container<T>::size
+  {
+  };
+
+  template<typename T> struct container_size<T&> : container_size<T>
+  {
+  };
+
+  template<typename T> struct container_size<T&&> : container_size<T>
+  {
+  };
+
+  template<typename T> struct container_size<T const&> : container_size<T>
+  {
+  };
+
+  template<typename T> struct container_size<T const&&> : container_size<T>
+  {
+  };
+
+  template<typename T> inline constexpr auto container_size_v = container_size<T>::value;
+
+  //================================================================================================
+  //! @ingroup traits
+  //! @brief Provides access to the type of the elements of a kumi::static_container.
+  //!
+  //! @tparam T kumi::static_container to access
+  //!
+  //! ## Helper type
+  //! @code
+  //! namespace kumi
+  //! {
+  //!   template<typename T> using container_type_t = typename container_type<T>::type;
+  //! }
+  //! @endcode
+  //================================================================================================
+  template<typename T> struct container_type : is_static_container<T>::value_type
+  {
+  };
+
+  template<typename T> struct container_type<T&> : container_type<T>
+  {
+  };
+
+  template<typename T> struct container_type<T&&> : container_type<T>
+  {
+  };
+
+  template<typename T> struct container_type<T const&> : container_type<T>
+  {
+  };
+
+  template<typename T> struct container_type<T const&&> : container_type<T>
+  {
+  };
+
+  template<typename T> using container_type_t = typename container_type<T>::type;
+}
+
 namespace kumi
 {
   //================================================================================================
@@ -404,4 +538,10 @@ namespace kumi
   // Forward declaration
   template<typename... Ts> struct tuple;
   template<typename... Ts> struct record;
+
+  template<typename T>
+  requires(is_static_container_v<T> && (_::non_empty_tuple<T> || _::empty_tuple<T>))
+  struct is_product_type<T> : std::true_type
+  {
+  };
 }

test/unit/adapt.cpp

@@ -9,6 +9,7 @@
 #include <kumi/kumi.hpp>
 #include <tts/tts.hpp>
 #include <tuple>
+#include <array>
 #include "test.hpp"
 
 TTS_CASE("Check adapted types model kumi::product_type concept")

test/unit/builder.cpp

@@ -9,6 +9,7 @@
 #include <kumi/kumi.hpp>
 #include <tts/tts.hpp>
 #include "test.hpp"
+#include <array>
 
 TTS_CASE("Check tuple_element of the output of result::builder_make_t")
 {

test/unit/convert.cpp

@@ -9,6 +9,8 @@
 #include <kumi/kumi.hpp>
 #include <tts/tts.hpp>
 #include "test.hpp"
+#include <array>
+#include <span>
 
 struct my_product_type
 {