Upgrade: put the new tuple_like concept into use

- integrate the concept definition into tuple-helper.hpp
- use it to replace the `is_Structured` traits check
- do not need `enable_if_TupleProtocol` any more

Integrate test coverage of the concept metafunctions
and the generalised get accessor

''This changeset was made at LAC 2025 in Lyon, France''

research/try.cpp

@@ -29,76 +29,6 @@
 
 using std::string;
 
-namespace lib {
-namespace meta {
-  
-  template<class TUP>
-  concept tuple_sized = requires
-    {
-      { std::tuple_size<TUP>::value } -> std::convertible_to<size_t>;
-    };
-  
-  
-  template<class TUP, std::size_t idx>
-  concept tuple_adl_accessible = requires(TUP tup)
-    {
-      typename std::tuple_element_t<idx, TUP>;
-      { get<idx>(tup) } -> std::convertible_to<std::tuple_element_t<idx, TUP>&>;
-    };
-  
-  template<class TUP, std::size_t idx>
-  concept tuple_mem_accessible = requires(TUP tup)
-    {
-      typename std::tuple_element_t<idx, TUP>;
-      { tup.template get<idx>() } -> std::convertible_to<std::tuple_element_t<idx, TUP>&>;
-    };
-  
-  template<class TUP, std::size_t idx>
-  concept tuple_element_accessible = tuple_mem_accessible<TUP,idx> or tuple_adl_accessible<TUP,idx>;
-  
-  template<class TUP>
-  concept tuple_accessible =
-    tuple_sized<TUP> and
-    WithIdxSeq<std::tuple_size_v<TUP>>::andAll([](auto idx)
-                                                {
-                                                 return tuple_element_accessible<TUP,idx>;
-                                                });
-  
-  
-  template<class TUP>
-  concept tuple_like = not is_reference_v<TUP>
-                   and tuple_sized<remove_cv_t<TUP>>
-                   and tuple_accessible<remove_cv_t<TUP>>;
-  
-  
-  template<std::size_t idx, class TUP>
-                            requires(tuple_like<std::remove_reference_t<TUP>>)
-  decltype(auto)
-  get (TUP&& tup)
-  {
-    using Tup = std::remove_reference_t<TUP>;
-    static_assert (0 < std::tuple_size_v<Tup>);
-    if constexpr (tuple_mem_accessible<Tup,0>)
-      {
-        if constexpr (std::is_reference_v<TUP>)
-          return tup.template get<idx>();
-        else
-          { // return value copy when tuple given as RValue
-            using Elm = std::tuple_element_t<idx, TUP>;
-            Elm elm(tup.template get<idx>());
-            return elm;
-          }
-      }
-    else
-      {
-        using std::get;
-        return get<idx> (std::forward<TUP> (tup));
-      }
-  }
-  
-}}//namespace lib::meta
-
-
 
 template<typename X>
 void
@@ -154,18 +84,18 @@ main (int, char**)
     using TupConstSeq = lib::meta::ElmTypes<const Tup>::Seq;
     SHOW_TYPE(TupConstSeq)
     
-    using T1 = decltype(lib::meta::get<0> (std::declval<Tup>()));
+    using T1 = decltype(lib::meta::getElm<0> (std::declval<Tup>()));
     SHOW_TYPE(T1)
-    using T2 = decltype(lib::meta::get<0> (std::declval<Tup&>()));
+    using T2 = decltype(lib::meta::getElm<0> (std::declval<Tup&>()));
     SHOW_TYPE(T2)
-    using T3 = decltype(lib::meta::get<0> (std::declval<Tup const&>()));
+    using T3 = decltype(lib::meta::getElm<0> (std::declval<Tup const&>()));
     SHOW_TYPE(T3)
     
-    using H1 = decltype(lib::meta::get<4> (std::declval<Hetero>()));
+    using H1 = decltype(lib::meta::getElm<4> (std::declval<Hetero>()));
     SHOW_TYPE(H1)
-    using H2 = decltype(lib::meta::get<4> (std::declval<Hetero&>()));
+    using H2 = decltype(lib::meta::getElm<4> (std::declval<Hetero&>()));
     SHOW_TYPE(H2)
-    using H3 = decltype(lib::meta::get<4> (std::declval<Hetero const&>()));
+    using H3 = decltype(lib::meta::getElm<4> (std::declval<Hetero const&>()));
     SHOW_TYPE(H3)
     
     cout <<  "\n.gulp." <<endl;

src/lib/meta/tuple-helper.hpp

@@ -78,6 +78,75 @@ namespace meta {
   template<class TUP>
   using disable_if_Tuple = lib::meta::disable_if<lib::meta::is_Tuple<std::remove_reference_t<TUP>>>;
   
+  using std::remove_cv_t;
+  using std::is_reference_v;
+  
+  
+  template<class TUP>
+  concept tuple_sized = requires
+    {
+      { std::tuple_size<TUP>::value } -> std::convertible_to<size_t>;
+    };
+  
+  
+  template<class TUP, std::size_t idx>
+  concept tuple_adl_accessible = requires(TUP tup)
+    {
+      typename std::tuple_element_t<idx, TUP>;
+      { get<idx>(tup) } -> std::convertible_to<std::tuple_element_t<idx, TUP>&>;
+    };
+  
+  template<class TUP, std::size_t idx>
+  concept tuple_mem_accessible = requires(TUP tup)
+    {
+      typename std::tuple_element_t<idx, TUP>;
+      { tup.template get<idx>() } -> std::convertible_to<std::tuple_element_t<idx, TUP>&>;
+    };
+  
+  template<class TUP, std::size_t idx>
+  concept tuple_element_accessible = tuple_mem_accessible<TUP,idx> or tuple_adl_accessible<TUP,idx>;
+  
+  template<class TUP>
+  concept tuple_accessible =
+    tuple_sized<TUP> and
+    WithIdxSeq<std::tuple_size_v<TUP>>::andAll([](auto idx)
+                                                {
+                                                 return tuple_element_accessible<TUP,idx>;
+                                                });
+  
+  
+  template<class TUP>
+  concept tuple_like = not is_reference_v<TUP>
+                   and tuple_sized<remove_cv_t<TUP>>
+                   and tuple_accessible<remove_cv_t<TUP>>;
+  
+  
+  template<std::size_t idx, class TUP>
+                            requires(tuple_like<std::remove_reference_t<TUP>>)
+  decltype(auto)
+  getElm (TUP&& tup)
+  {
+    using Tup = std::remove_reference_t<TUP>;
+    static_assert (0 < std::tuple_size_v<Tup>);
+    if constexpr (tuple_mem_accessible<Tup,0>)
+      {
+        if constexpr (std::is_reference_v<TUP>)
+          return tup.template get<idx>();
+        else
+          { // return value copy when tuple given as RValue
+            using Elm = std::tuple_element_t<idx, TUP>;
+            Elm elm(tup.template get<idx>());
+            return elm;
+          }
+      }
+    else
+      {     // ▽▽▽ ADL
+        using std::get;
+        return get<idx> (std::forward<TUP> (tup));
+      }
+  }
+  
+  
   
   
   namespace { // apply to tuple-like : helpers...
@@ -86,8 +155,7 @@ namespace meta {
     template<typename FUN, typename TUP, size_t...Idx>
     constexpr decltype(auto)
     __unpack_and_apply (FUN&& f, TUP&& tup, std::index_sequence<Idx...>)
-    {         // ▽▽▽ ADL
+    {
-      using std::get;
       return std::invoke (std::forward<FUN> (f)
                          ,get<Idx> (std::forward<TUP>(tup))...
                          );

tests/library/meta/tuple-diagnostics.hpp

@@ -66,9 +66,8 @@ namespace test {
   /* ===== printing Tuple types and contents ===== */ 
   
   
-  template<typename TUP>
+  template<tuple_like TUP>
-  inline                enable_if<is_Tuple<TUP>,
+  inline string
-  string                >
   showType ()
   {
     using TypeList = typename RebindTupleTypes<TUP>::List;

tests/library/meta/tuple-helper-test.cpp

@@ -29,6 +29,7 @@
 #include "meta/tuple-diagnostics.hpp"
 #include "lib/format-string.hpp"
 #include "lib/format-cout.hpp"
+#include "lib/hetero-data.hpp"
 #include "lib/test/diagnostic-output.hpp"////////////////TODO
 
 #include <string>
@@ -79,6 +80,7 @@ namespace test {
           check_diagnostics();
           check_tuple_from_Typelist();
           demonstrate_generic_iteration();
+          verify_tuple_like_concept();
         }
       
       
@@ -227,6 +229,106 @@ namespace test {
           CHECK (not ElmTypes<Tup>::AndAll<std::is_integral>());  //   ... __and_<is_integral<int>,is_integral<double>,is_integral<char>>
           CHECK (    ElmTypes<Tup>::OrAll<std::is_integral>());
         }
+      
+      
+      
+      template<typename X>
+      string
+      render()
+        {
+          return lib::test::showType<X>();
+        }
+      
+      template<tuple_like X>
+      string
+      render()
+        {
+          string res{"Tup"};
+          res +="("+toString(std::tuple_size_v<X>)+") : "+ lib::test::showType<X>();
+          lib::meta::forEachIDX<X> ([&](auto i)
+                                      {
+                                        using Elm = std::tuple_element_t<i, X>;
+                                        res += " ▷"+ toString(uint(i)) + ": " + lib::test::showType<Elm>();
+                                      });
+          return res;
+        }
+
+      /** @test verify construction of a concept to detect _tuple-like_ classes,
+       *        which conform to the »tuple protocol« and can thus be used
+       *        in structural bindings
+       *      - the size of such an entity can be detected at compile time
+       *      - essentially, these can be considered as _product types_ — which implies
+       *        that there are N element types
+       *      - access to the corresponding member data is possible either through a
+       *        `get` member function or free function detected by ADL
+       */
+      void
+      verify_tuple_like_concept()
+        {
+          using Tup = std::tuple<long,short>;
+          using Arr = std::array<int,3>;
+          using Het = lib::HeteroData<int,string>::Chain<short>::ChainExtent<bool,lib::meta::Nil>::ChainType;
+          
+          CHECK (    tuple_sized<Tup> );
+          CHECK (    tuple_sized<Arr> );
+          CHECK (    tuple_sized<Het> );
+          CHECK (not tuple_sized<int> );
+          
+          CHECK (   (tuple_element_accessible<Tup,0>));
+      //  CHECK (   (tuple_element_accessible<Tup,2>));
+          CHECK (   (tuple_element_accessible<Het,0>));
+          CHECK (    tuple_accessible<Tup> );
+          CHECK (    tuple_accessible<Arr> );
+          CHECK (    tuple_accessible<Het> );
+          CHECK (not tuple_accessible<int> );
+          
+          CHECK (    tuple_like<Tup> );
+          CHECK (    tuple_like<Arr> );
+          CHECK (    tuple_like<Het> );
+          CHECK (not tuple_like<int> );
+          
+          // the tuple, the array and the HeteroData are tuple-like,
+          // and will be handled by a special overload, exploiting the additional features
+          CHECK (render<Tup>() == "Tup(2) : tuple<long, short> ▷0: long ▷1: short"_expect);
+          CHECK (render<Arr>() == "Tup(3) : array<int, 3ul> ▷0: int ▷1: int ▷2: int"_expect);
+          CHECK (render<Het>() == "Tup(5) : HeteroData<Node<StorageFrame<0ul, int, string>, "
+                                           "Node<StorageFrame<1ul, short>, "
+                                           "Node<StorageFrame<2ul, bool, Nil>, Nil> > > > "
+                                  "▷0: int ▷1: string ▷2: short ▷3: bool ▷4: Nil"_expect);
+          // the plain type `int` is not tuple-like and thus the fallback case is picked
+          CHECK (render<int>() == "int"_expect);
+          
+          CHECK (std::tuple_size_v<const Tup> == 2 );
+          
+          using Elm1 = std::tuple_element_t<1, const Tup>;
+          CHECK (lib::test::showType<Elm1>() == "const short"_expect);
+          
+          // note: a const tuple will add const qualification to each element type
+          using TupConstSeq = lib::meta::ElmTypes<const Tup>::Seq;
+          CHECK (lib::test::showType<TupConstSeq>() == "Types<long const, short const>"_expect);
+          
+          
+          // a unified access function `getElm`
+          // which works both with access by member or free function
+          
+          using T1 = decltype(lib::meta::getElm<0> (std::declval<Tup>()));
+          CHECK (lib::test::showType<T1>() == "long &&"_expect);
+          
+          using T2 = decltype(lib::meta::getElm<0> (std::declval<Tup&>()));
+          CHECK (lib::test::showType<T2>() == "long&"_expect);
+          
+          using T3 = decltype(lib::meta::getElm<0> (std::declval<Tup const&>()));
+          CHECK (lib::test::showType<T3>() == "long const&"_expect);
+          
+          using H1 = decltype(lib::meta::getElm<4> (std::declval<Het>()));
+          CHECK (lib::test::showType<H1>() == "Nil"_expect);
+          
+          using H2 = decltype(lib::meta::getElm<4> (std::declval<Het&>()));
+          CHECK (lib::test::showType<H2>() == "Nil&"_expect);
+          
+          using H3 = decltype(lib::meta::getElm<4> (std::declval<Het const&>()));
+          CHECK (lib::test::showType<H3>() == "Nil const&"_expect);
+        }
     };
   
   

tests/library/meta/typelist-diagnostics.hpp

@@ -188,7 +188,7 @@ namespace meta {
       return printSublist<TypeList>();
     }
     
-    //  Note: we define overloads of this function for other types, especially Tuples
+    //  Note: we define further overloads of this function for other types, especially Tuples