Strip most of the iterator typedefs off of the various intermediate layers of recursive_iterator.

include/iterator/detail/flatten_iterator_layer.hpp

@@ -24,22 +24,6 @@ namespace iterator { namespace detail {
 
   protected:
     using recursive_category = continue_layer_tag_t;
-    using next_value_type =
-        typename next_layer_type<typename super::value_type,
-                                 typename super::recursive_category>::type;
-    using next_reference =
-        typename next_layer_type<typename super::reference,
-                                 typename super::recursive_category>::type;
-
-  public:
-    using value_type =
-        decltype(std::tuple_cat(std::make_tuple(std::declval<key_type>()),
-                                std::declval<next_value_type>()));
-    using reference = decltype(std::tuple_cat(
-        std::tie(std::declval<key_type>()), std::declval<next_reference>()));
-    using pointer = detail::arrow_proxy<reference>;
-    using difference_type = std::ptrdiff_t;
-    using iterator_category = std::forward_iterator_tag;
 
   public:
     flatten_iterator_layer() = default;
@@ -63,8 +47,11 @@ namespace iterator { namespace detail {
      * even a key-type of pair/tuple will not be unwrapped.
      */
     decltype(auto) operator*() const {
+      using next_t =
+          typename next_layer_type<decltype(super::get()),
+                                   typename super::recursive_category>::type;
       return std::tuple_cat(std::forward_as_tuple(std::get<0>(layer::get())),
-                            next_reference(super::get()));
+                            next_t(super::get()));
     }
 
     /**

include/iterator/detail/recursive_iterator_base.hpp

@@ -19,9 +19,6 @@ namespace iterator { namespace detail {
 
   protected:
     using recursive_category = terminal_layer_tag_t;
-    using reference = decltype(*std::declval<super>());
-    using value_type = std::remove_cv_t<std::remove_reference_t<reference>>;
-    using pointer = decltype(std::declval<super>().operator->());
 
   public:
     using super::super;
@@ -58,19 +55,12 @@ namespace iterator { namespace detail {
   protected:
     using recursive_category = continue_layer_tag_t;
 
-  public:
-    using value_type = std::tuple<first_type, second_type>;
-    using reference = std::tuple<first_type &, second_type &>;
-
   public:
     using super::super;
     recursive_iterator_base(super const & iter) : super(iter) {}
     recursive_iterator_base(super && iter) : super(std::move(iter)) {}
     recursive_iterator_base() = default;
 
-    // TODO: Get rid of this again
-    reference operator*() const { return get(); }
-
   protected:
     /**
      * An alternative function to operator*(), which allows single layer
@@ -78,7 +68,7 @@ namespace iterator { namespace detail {
      * underlying value/reference type, and nested containers to propogate
      * a tuple or a pair as necessary.
      */
-    reference get() const {
+    std::tuple<first_type &, second_type &> get() const {
       auto & pair = super::operator*();
       return std::tie(pair.first, pair.second);
     }

include/iterator/detail/recursive_iterator_layer.hpp

@@ -28,13 +28,6 @@ namespace iterator { namespace detail {
   protected:
     using recursive_category = continue_layer_tag_t;
 
-  public:
-    using reference = decltype(*std::declval<super>());
-    using value_type = std::remove_cv_t<std::remove_reference_t<reference>>;
-    using pointer = decltype(std::declval<super>().operator->());
-    using difference_type = std::ptrdiff_t;
-    using iterator_category = std::forward_iterator_tag;
-
   public:
     recursive_iterator_layer() = default;
     explicit recursive_iterator_layer(layer v) : recursive_iterator_layer() {

include/iterator/recursive_iterator.hpp

@@ -81,6 +81,11 @@ namespace iterator {
       : public detail::bounded_recursive_iterator_impl<Iterator, 1, N> {
   public:
     using super = detail::bounded_recursive_iterator_impl<Iterator, 1, N>;
+    using reference = decltype(*std::declval<super>());
+    using value_type = std::remove_cv_t<std::remove_reference_t<reference>>;
+    using pointer = decltype(std::declval<super>().operator->());
+    using difference_type = std::ptrdiff_t;
+    using iterator_category = std::forward_iterator_tag;
 
   public:
     using super::super;