flatten partially works

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.20)
 include(cmake/color.cmake)
-set(BLT_VERSION 4.0.33)
+set(BLT_VERSION 4.0.34)
 
 set(BLT_TARGET BLT)
 

include/blt/iterator/enumerate.h

@@ -25,17 +25,6 @@ namespace blt
 {
     namespace iterator
     {
-        /**
-         * struct which is returned by the enumerator.
-         * @tparam T type to store.
-         */
-        template <typename T>
-        struct enumerate_item
-        {
-            const size_t index;
-            T value;
-        };
-
         template <typename Iter>
         class enumerate_wrapper : public passthrough_wrapper<Iter, enumerate_wrapper<Iter>>
         {

include/blt/iterator/flatten.h

@@ -20,43 +20,34 @@
 #define BLT_ITERATOR_FLATTEN_H
 
 #include <blt/iterator/common.h>
+#include <blt/meta/type_traits.h>
 #include <tuple>
 
 namespace blt::iterator
 {
     namespace detail
     {
-        template<typename T>
-        struct make_tuple
+        template <typename Tuple>
+        static auto flatten(Tuple&& tuple) -> decltype(auto)
         {
-            using type = std::tuple<T>;
-
-            static auto convert(T& f)
+            using Decay = std::decay_t<Tuple>;
+            if constexpr (meta::is_tuple_v<Decay> || meta::is_pair_v<Decay>)
             {
-                return std::forward_as_tuple(f);
-            }
-
-            static auto convert(T&& f)
+                return std::apply([](auto&&... args)
+                {
+                    return std::tuple_cat(flatten(std::forward<decltype(args)>(args))...);
+                }, std::forward<Tuple>(tuple));
+            } else
             {
-                return std::forward_as_tuple(f);
+                if constexpr (std::is_lvalue_reference_v<Tuple>)
+                {
+                    return std::forward_as_tuple(std::forward<Tuple>(tuple));
+                } else
+                {
+                    return std::make_tuple(std::forward<Tuple>(tuple));
+                }
             }
-        };
-
-        template<typename... Args>
-        struct make_tuple<std::tuple<Args...>>
-        {
-            using type = std::tuple<Args...>;
-
-            static std::tuple<Args...>& convert(std::tuple<Args...>& lvalue)
-            {
-                return lvalue;
-            }
-
-            static std::tuple<Args...>&& convert(std::tuple<Args...>&& rvalue)
-            {
-                return rvalue;
-            }
-        };
+        }
     }
 
     template <typename Iter>
@@ -64,19 +55,19 @@ namespace blt::iterator
     {
     public:
         using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
-        // using value_type = std::invoke_result_t<Func, meta::deref_return_t<Iter>>;
+        using value_type = std::remove_reference_t<decltype(detail::flatten(*std::declval<Iter>()))>;
         using difference_type = ptrdiff_t;
-        // using pointer = value_type;
-        // using reference = value_type;
+        using pointer = value_type*;
+        using reference = value_type&;
 
         explicit flatten_wrapper(Iter iter):
-            deref_only_wrapper<Iter, flatten_wrapper<Iter>>(std::move(iter))
+            deref_only_wrapper<Iter, flatten_wrapper>(std::move(iter))
         {
         }
 
-        reference operator*() const
+        auto operator*() const -> decltype(auto)
         {
-            return func(*this->iter);
+            return detail::flatten(*this->iter);
         }
     };
 }

include/blt/iterator/fwddecl.h

@@ -19,6 +19,8 @@
 #ifndef BLT_ITERATOR_FWDDECL_H
 #define BLT_ITERATOR_FWDDECL_H
 
+#include <utility>
+
 namespace blt
 {
     template<typename... Iter>
@@ -33,7 +35,7 @@ namespace blt
         struct iterator_pair;
         
         template<typename T>
-        struct enumerate_item;
+        using enumerate_item = std::pair<size_t, T>;
         
         template<typename Iter>
         class enumerate_wrapper;

include/blt/meta/type_traits.h

@@ -24,6 +24,15 @@
 
 namespace blt::meta
 {
+    namespace detail
+    {
+        template<typename... Args>
+        void empty_apply_function(Args...)
+        {
+
+        }
+    }
+
     template <typename T>
     using remove_cvref_t = std::remove_volatile_t<std::remove_const_t<std::remove_reference_t<T>>>;
 
@@ -50,15 +59,24 @@ namespace blt::meta
     {
     };
 
-    template<typename T>
+    template <typename T>
     static constexpr bool is_tuple_v = is_tuple<T>::value;
 
-    template<typename T>
+    template <typename T>
     static constexpr bool is_pair_v = is_pair<T>::value;
 
-    template<typename T>
-    static constexpr bool is_tuple_like_v = is_tuple_v<T> || is_pair_v<T>;
+    template <typename, typename = void>
+    struct is_tuple_like : std::false_type
+    {
+    };
 
+    template <typename T>
+    struct is_tuple_like<T, std::void_t<std::tuple_size<T>, std::tuple_element<0, T>>> : std::true_type
+    {
+    };
+
+    template <typename T>
+    inline constexpr bool is_tuple_like_v = is_tuple_like<T>::value;
 }
 
 #endif // BLT_META_TYPE_TRAITS_H