refactor: change type names to CamelCase

include/iterator/capture_iterator.h

@@ -16,9 +16,9 @@
 namespace iterator {
 
 template <typename It>
-class capture_iterator : public proxy<It, capture_iterator<It>> {
+class capture_iterator : public Proxy<It, capture_iterator<It>> {
 public:
-  using super_t = proxy<It, capture_iterator<It>>;
+  using super_t = Proxy<It, capture_iterator<It>>;
   using value_type = typename std::iterator_traits<It>::value_type;
   using difference_type = typename std::iterator_traits<It>::difference_type;
 

include/iterator/cascade_iterator.h

@@ -11,70 +11,74 @@
 
 namespace iterator {
 template <typename It, typename Projs, typename MaxDepth>
-class cascade_iterator;
+class ProjectingRecursiveIterator;
 
 template <typename It, typename... Projs, typename MaxDepth>
-class cascade_iterator<It, detail::Projections<Projs...>, MaxDepth>
-    : public recursive_iterator_helper<It, MaxDepth,
-                                       detail::Projections<Projs...>>::type,
-      public facade<
-          cascade_iterator<It, detail::Projections<Projs...>, MaxDepth>> {
+class ProjectingRecursiveIterator<It, detail::Projections<Projs...>, MaxDepth>
+    : public RecursiveHelper<It, MaxDepth, detail::Projections<Projs...>>::type,
+      public Facade<ProjectingRecursiveIterator<
+          It, detail::Projections<Projs...>, MaxDepth>> {
 public:
   using sentinel_type = sentinel_t;
 
 public:
-  cascade_iterator() = default;
+  ProjectingRecursiveIterator() = default;
 
-  explicit cascade_iterator(Range auto & range, Projs... projs)
-      : cascade_iterator(end_aware_iterator(range), projs...) {}
+  explicit ProjectingRecursiveIterator(Range auto & range, Projs... projs)
+      : ProjectingRecursiveIterator(EndAwareIterator(range), projs...) {}
 
-  explicit cascade_iterator(Range auto & range, MaxDepth, Projs... projs)
-      : cascade_iterator(end_aware_iterator(range), projs...) {}
+  explicit ProjectingRecursiveIterator(Range auto & range, MaxDepth,
+                                       Projs... projs)
+      : ProjectingRecursiveIterator(EndAwareIterator(range), projs...) {}
 
-  explicit cascade_iterator(end_aware_iterator<It> iter, MaxDepth,
-                            Projs... projs)
-      : cascade_iterator::recursive_iterator_base(iter, projs...) {}
+  explicit ProjectingRecursiveIterator(EndAwareIterator<It> iter, MaxDepth,
+                                       Projs... projs)
+      : ProjectingRecursiveIterator::RecursiveBase(iter, projs...) {}
 
-  explicit cascade_iterator(end_aware_iterator<It> iter, Projs... projs)
-      : cascade_iterator::recursive_iterator_base(iter, projs...) {}
+  explicit ProjectingRecursiveIterator(EndAwareIterator<It> iter,
+                                       Projs... projs)
+      : ProjectingRecursiveIterator::RecursiveBase(iter, projs...) {}
 
   template <typename Ot>
-  explicit cascade_iterator(end_aware_iterator<Ot> other, Projs... projs)
-      : cascade_iterator(end_aware_iterator<It>(other), projs...) {}
+  explicit ProjectingRecursiveIterator(EndAwareIterator<Ot> other,
+                                       Projs... projs)
+      : ProjectingRecursiveIterator(EndAwareIterator<It>(other), projs...) {}
 
   template <typename Ot>
-  explicit cascade_iterator(end_aware_iterator<Ot> other, MaxDepth,
-                            Projs... projs)
-      : cascade_iterator(end_aware_iterator<It>(other), projs...) {}
+  explicit ProjectingRecursiveIterator(EndAwareIterator<Ot> other, MaxDepth,
+                                       Projs... projs)
+      : ProjectingRecursiveIterator(EndAwareIterator<It>(other), projs...) {}
 };
 
 template <Range R, typename... Projs>
-cascade_iterator(R, Projs...)
-    -> cascade_iterator<iterator_t<R>, detail::Projections<Projs...>,
-                        bounded<sizeof...(Projs) + 1>>;
+ProjectingRecursiveIterator(R, Projs...)
+    -> ProjectingRecursiveIterator<iterator_t<R>, detail::Projections<Projs...>,
+                                   bounded<sizeof...(Projs) + 1>>;
 
 template <typename It, typename... Projs>
-cascade_iterator(end_aware_iterator<It>, Projs...)
-    -> cascade_iterator<It, detail::Projections<Projs...>,
-                        bounded<sizeof...(Projs) + 1>>;
+ProjectingRecursiveIterator(EndAwareIterator<It>, Projs...)
+    -> ProjectingRecursiveIterator<It, detail::Projections<Projs...>,
+                                   bounded<sizeof...(Projs) + 1>>;
 
 template <Range R, typename... Projs, size_t N>
   requires(N > sizeof...(Projs))
-cascade_iterator(R, bounded<N>, Projs...)
-    -> cascade_iterator<iterator_t<R>, detail::Projections<Projs...>,
-                        bounded<N>>;
+ProjectingRecursiveIterator(R, bounded<N>, Projs...)
+    -> ProjectingRecursiveIterator<iterator_t<R>, detail::Projections<Projs...>,
+                                   bounded<N>>;
 
 template <typename It, typename... Projs, size_t N>
   requires(N > sizeof...(Projs))
-cascade_iterator(end_aware_iterator<It>, bounded<N>, Projs...)
-    -> cascade_iterator<It, detail::Projections<Projs...>, bounded<N>>;
+ProjectingRecursiveIterator(EndAwareIterator<It>, bounded<N>, Projs...)
+    -> ProjectingRecursiveIterator<It, detail::Projections<Projs...>,
+                                   bounded<N>>;
 
 template <Range R, typename... Projs>
-cascade_iterator(R, unbounded, Projs...)
-    -> cascade_iterator<iterator_t<R>, detail::Projections<Projs...>,
-                        unbounded>;
+ProjectingRecursiveIterator(R, unbounded, Projs...)
+    -> ProjectingRecursiveIterator<iterator_t<R>, detail::Projections<Projs...>,
+                                   unbounded>;
 
 template <typename It, typename... Projs>
-cascade_iterator(end_aware_iterator<It>, unbounded, Projs...)
-    -> cascade_iterator<It, detail::Projections<Projs...>, unbounded>;
+ProjectingRecursiveIterator(EndAwareIterator<It>, unbounded, Projs...)
+    -> ProjectingRecursiveIterator<It, detail::Projections<Projs...>,
+                                   unbounded>;
 }

include/iterator/detail/arrow_proxy.h

@@ -4,11 +4,11 @@
 #pragma once
 
 namespace iterator::detail {
-template <typename Reference> struct arrow_proxy {
-  arrow_proxy(Reference r) : r(std::move(r)) {}
+template <typename Reference> struct ArrowProxy {
+  ArrowProxy(Reference r) : r(std::move(r)) {}
   Reference r;
   Reference * operator->() { return std::addressof(r); }
 };
 
-template <typename R> arrow_proxy(R r) -> arrow_proxy<R>;
+template <typename R> ArrowProxy(R r) -> ArrowProxy<R>;
 }

include/iterator/detail/recursive_expander.h

@@ -22,12 +22,12 @@ using projection_t = std::invoke_result_t<Proj, std::iter_reference_t<It>,
 template <typename It, typename Projs, typename MaxDepth, size_t N = 0,
           typename V = std::decay_t<projection_t<Projs, It, N>>>
 struct RecursiveExpander {
-  using type = std::tuple<end_aware_iterator<It>>;
+  using type = std::tuple<EndAwareIterator<It>>;
 };
 
 template <typename It, typename Projs, size_t N>
 struct RecursiveExpander<It, Projs, bounded<N + 1>, N> {
-  using type = std::tuple<end_aware_iterator<It>>;
+  using type = std::tuple<EndAwareIterator<It>>;
 };
 
 template <typename It, typename Projs, typename MaxDepth, size_t N, Range V>
@@ -37,8 +37,8 @@ struct RecursiveExpander<It, Projs, MaxDepth, N, V> {
   using expand_next = RecursiveExpander<iterator_t<projected_value_type>, Projs,
                                         MaxDepth, N + 1>;
 
-  using type = tuple_cat_t<std::tuple<end_aware_iterator<It>>,
-                           typename expand_next::type>;
+  using type =
+      tuple_cat_t<std::tuple<EndAwareIterator<It>>, typename expand_next::type>;
 };
 
 template <typename It, typename Projs, typename MaxDepth, size_t N,
@@ -51,7 +51,7 @@ struct RecursiveExpander<It, Projs, MaxDepth, N, V> {
   using expand_next = RecursiveExpander<iterator_t<projected_value_type>, Projs,
                                         MaxDepth, N + 1>;
 
-  using type = tuple_cat_t<std::tuple<end_aware_iterator<It>>,
-                           typename expand_next::type>;
+  using type =
+      tuple_cat_t<std::tuple<EndAwareIterator<It>>, typename expand_next::type>;
 };
 }

include/iterator/end_aware_iterator.h

@@ -16,26 +16,26 @@
 
 namespace iterator {
 /**
- * @class end_aware_iterator
+ * @class EndAwareIterator
  * @brief An iterator that keeps track of the relative end of the range.
  *
  * @tparam It The underlying iterator type
  */
 template <typename It>
-class end_aware_iterator : public proxy<It, end_aware_iterator<It>> {
+class EndAwareIterator : public Proxy<It, EndAwareIterator<It>> {
 public:
-  using super_t = proxy<It, end_aware_iterator<It>>;
+  using super_t = Proxy<It, EndAwareIterator<It>>;
   using sentinel_type = sentinel_t;
 
 public:
-  end_aware_iterator() = default;
-  end_aware_iterator(It it, It end) : super_t(it), end_(end) {}
+  EndAwareIterator() = default;
+  EndAwareIterator(It it, It end) : super_t(it), end_(end) {}
 
-  end_aware_iterator(Range auto & container)
+  EndAwareIterator(Range auto & container)
       : super_t(std::begin(container)), end_(std::end(container)) {}
 
   template <typename Ot>
-  end_aware_iterator(end_aware_iterator<Ot> const & other)
+  EndAwareIterator(EndAwareIterator<Ot> const & other)
       : super_t(other.impl()), end_(other.end_) {}
 
   operator std::ranges::subrange<It>() const {
@@ -50,7 +50,7 @@ public:
     }
   }
 
-  friend auto operator-(sentinel_type, end_aware_iterator const & self)
+  friend auto operator-(sentinel_type, EndAwareIterator const & self)
     requires(std::random_access_iterator<It>)
   {
     return self.end() - self.impl();
@@ -60,16 +60,15 @@ protected:
   It end() const { return end_; }
 
 private:
-  template <typename O> friend class end_aware_iterator;
+  template <typename O> friend class EndAwareIterator;
   It end_;
 };
 
-template <typename C>
-end_aware_iterator(C &&) -> end_aware_iterator<iterator_t<C>>;
-template <typename It> end_aware_iterator(It, It) -> end_aware_iterator<It>;
+template <typename C> EndAwareIterator(C &&) -> EndAwareIterator<iterator_t<C>>;
+template <typename It> EndAwareIterator(It, It) -> EndAwareIterator<It>;
 template <typename It>
-end_aware_iterator(end_aware_iterator<It>, end_aware_iterator<It>)
-    -> end_aware_iterator<It>;
+EndAwareIterator(EndAwareIterator<It>, EndAwareIterator<It>)
+    -> EndAwareIterator<It>;
 }
 
 #include <iterator/detail/undef.h>

include/iterator/facade.h

@@ -9,7 +9,7 @@
 #include <iterator/detail/macro.h>
 
 namespace iterator {
-template <typename CRTP> class facade {
+template <typename CRTP> class Facade {
 private:
   using self_type = CRTP;
 
@@ -20,7 +20,7 @@ public:
     if constexpr (std::is_reference<decltype(**this)>{}) {
       return std::addressof(**this);
     } else {
-      return detail::arrow_proxy{**this};
+      return detail::ArrowProxy{**this};
     }
   }
 
@@ -129,7 +129,7 @@ protected:
 }
 
 template <typename It>
-  requires std::is_base_of_v<iterator::facade<It>, It>
+  requires std::is_base_of_v<iterator::Facade<It>, It>
 struct std::iterator_traits<It> {
   static const It & _it;
   using reference = decltype(*_it);

include/iterator/filter_iterator.h

@@ -17,25 +17,24 @@
 
 namespace iterator {
 template <typename Iter, typename Pred>
-class filter_iterator : public facade<filter_iterator<Iter, Pred>> {
+class FilterIterator : public Facade<FilterIterator<Iter, Pred>> {
 public:
   using sentinel_type = sentinel_t;
-  using super_t = filter_iterator::facade;
+  using super_t = FilterIterator::Facade;
 
 public:
-  filter_iterator() = default;
+  FilterIterator() = default;
 
-  filter_iterator(Range auto & c, Pred pred)
-      : base_(c), pred_(std::move(pred)) {
+  FilterIterator(Range auto & c, Pred pred) : base_(c), pred_(std::move(pred)) {
     if (should_advance()) { increment(); }
   }
 
-  filter_iterator(Iter curr, Iter end, Pred pred)
-      : base_(end_aware_iterator(curr, end)), pred_(std::move(pred)) {
+  FilterIterator(Iter curr, Iter end, Pred pred)
+      : base_(EndAwareIterator(curr, end)), pred_(std::move(pred)) {
     if (should_advance()) { increment(); }
   }
 
-  filter_iterator(end_aware_iterator<Iter> curr, Pred pred)
+  FilterIterator(EndAwareIterator<Iter> curr, Pred pred)
       : base_(curr), pred_(std::move(pred)) {
     if (should_advance()) { increment(); }
   }
@@ -57,7 +56,7 @@ public:
   }
 
   bool at_end() const { return base_.at_end(); }
-  bool equal_to(filter_iterator const & other) const {
+  bool equal_to(FilterIterator const & other) const {
     return base_ == other.base_;
   }
 
@@ -66,16 +65,16 @@ public:
     return !base_.at_end() && !std::invoke(pred_, dereference());
   }
 
-  end_aware_iterator<Iter> base_;
+  EndAwareIterator<Iter> base_;
   Pred pred_;
 };
 
 template <typename C, typename P>
-filter_iterator(C &, P) -> filter_iterator<iterator_t<C>, P>;
+FilterIterator(C &, P) -> FilterIterator<iterator_t<C>, P>;
 template <typename It, typename P>
-filter_iterator(end_aware_iterator<It>, P) -> filter_iterator<It, P>;
+FilterIterator(EndAwareIterator<It>, P) -> FilterIterator<It, P>;
 template <typename It, typename P>
-filter_iterator(It, It, P) -> filter_iterator<It, P>;
+FilterIterator(It, It, P) -> FilterIterator<It, P>;
 }
 
 #include <iterator/detail/undef.h>

include/iterator/forwards.h

@@ -14,24 +14,24 @@ namespace iterator {
 struct sentinel_t;
 
 // Iterator types
-template <typename It> class end_aware_iterator;
-template <typename It, typename Predicate> class filter_iterator;
-template <typename OIt> class joining_iterator;
-template <typename It> class unkeyed_iterator;
-template <typename... Its> class zip_iterator;
+template <typename It> class EndAwareIterator;
+template <typename It, typename Predicate> class FilterIterator;
+template <typename OIt> class JoinIterator;
+template <typename It> class ValuesIterator;
+template <typename... Its> class ZipIterator;
 
 struct unbounded {};
 template <size_t N>
   requires(N > 0)
 struct bounded {};
 
-template <typename It, typename MaxDepth = unbounded> class recursive_iterator;
+template <typename It, typename MaxDepth = unbounded> class RecursiveIterator;
 template <typename It, size_t N>
-using recursive_iterator_n = recursive_iterator<It, bounded<N>>;
+using RecursiveIteratorN = RecursiveIterator<It, bounded<N>>;
 
-template <typename CRTP> class facade;
+template <typename CRTP> class Facade;
 
 template <typename It, typename CRTP,
           typename = typename std::iterator_traits<It>::iterator_category>
-class proxy;
+class Proxy;
 }

include/iterator/indexed_iterator.h

@@ -16,13 +16,13 @@
 
 namespace iterator {
 template <typename It>
-class indexed_iterator : public facade<indexed_iterator<It>> {
+class indexed_iterator : public Facade<indexed_iterator<It>> {
 public:
   using reference = std::pair<size_t, DEREF_TYPE(It)>;
   using difference_type = typename std::iterator_traits<It>::difference_type;
 
 private:
-  using super_t = facade<indexed_iterator<It>>;
+  using super_t = Facade<indexed_iterator<It>>;
 
 public:
   indexed_iterator() = default;

include/iterator/join_iterator.h

@@ -17,43 +17,39 @@
 #include <iterator/detail/macro.h>
 
 namespace iterator {
-template <typename It>
-class joining_iterator : public facade<joining_iterator<It>> {
+template <typename It> class JoinIterator : public Facade<JoinIterator<It>> {
 private:
-  template <typename Ot> friend class joining_iterator;
+  template <typename Ot> friend class JoinIterator;
   constexpr static bool requires_caching = !std::is_reference_v<DEREF_TYPE(It)>;
 
 public:
   using sentinel_type = sentinel_t;
   using outer_iterator_t =
       std::conditional_t<requires_caching,
-                         capture_iterator<end_aware_iterator<It>>,
-                         end_aware_iterator<It>>;
+                         capture_iterator<EndAwareIterator<It>>,
+                         EndAwareIterator<It>>;
   using inner_iterator_t =
-      end_aware_iterator<iterator_t<DEREF_TYPE(outer_iterator_t)>>;
+      EndAwareIterator<iterator_t<DEREF_TYPE(outer_iterator_t)>>;
 
 private:
   outer_iterator_t outer_;
   inner_iterator_t inner_;
 
 public:
-  joining_iterator() = default;
+  JoinIterator() = default;
 
   template <typename Ot>
-  joining_iterator(joining_iterator<Ot> const & other) : outer_(other.outer_) {
+  JoinIterator(JoinIterator<Ot> const & other) : outer_(other.outer_) {
     safely_init_inner_iterator(other.outer_, other.inner_);
   }
 
-  joining_iterator(Range auto & container) : outer_(FWD(container)) {
+  JoinIterator(Range auto & container) : outer_(FWD(container)) {
     update_iterator();
   }
 
-  joining_iterator(outer_iterator_t outer) : outer_(outer) {
-    update_iterator();
-  }
+  JoinIterator(outer_iterator_t outer) : outer_(outer) { update_iterator(); }
 
-  joining_iterator(outer_iterator_t const & outer,
-                   inner_iterator_t const & inner)
+  JoinIterator(outer_iterator_t const & outer, inner_iterator_t const & inner)
       : outer_(outer) {
     safely_init_inner_iterator(outer, inner);
   }
@@ -68,7 +64,7 @@ public:
   decltype(auto) dereference() const { return *inner_; }
 
   bool at_end() const { return outer_.at_end(); }
-  bool equal_to(joining_iterator const & other) const {
+  bool equal_to(JoinIterator const & other) const {
     return outer_ == other.outer_ && inner_ == other.inner_;
   }
 
@@ -94,9 +90,8 @@ private:
   }
 };
 
-template <typename C> joining_iterator(C &) -> joining_iterator<iterator_t<C>>;
-template <typename JI>
-joining_iterator(end_aware_iterator<JI>) -> joining_iterator<JI>;
+template <typename C> JoinIterator(C &) -> JoinIterator<iterator_t<C>>;
+template <typename JI> JoinIterator(EndAwareIterator<JI>) -> JoinIterator<JI>;
 }
 
 #include <iterator/detail/undef.h>

include/iterator/proxy.h

@@ -7,7 +7,7 @@
 
 namespace iterator {
 template <typename It, typename Self, typename Cat>
-class proxy : public facade<Self> {
+class Proxy : public Facade<Self> {
 public:
   static constexpr bool single_pass_iterator = true;
 
@@ -15,9 +15,9 @@ private:
   It impl_;
 
 public:
-  proxy() = default;
-  proxy(It impl) : impl_(impl) {}
-  template <typename... Args> proxy(Args &&... args) : impl_(FWD(args)...) {}
+  Proxy() = default;
+  Proxy(It impl) : impl_(impl) {}
+  template <typename... Args> Proxy(Args &&... args) : impl_(FWD(args)...) {}
 
   decltype(auto) dereference() const { return *impl_; }
   void increment() { ++impl_; }
@@ -33,14 +33,14 @@ protected:
 };
 
 template <typename It, typename Self>
-class proxy<It, Self, std::forward_iterator_tag> : public facade<Self> {
+class Proxy<It, Self, std::forward_iterator_tag> : public Facade<Self> {
 private:
   It impl_;
 
 public:
-  proxy() = default;
-  proxy(It impl) : impl_(impl) {}
-  template <typename... Args> proxy(Args &&... args) : impl_(FWD(args)...) {}
+  Proxy() = default;
+  Proxy(It impl) : impl_(impl) {}
+  template <typename... Args> Proxy(Args &&... args) : impl_(FWD(args)...) {}
 
   decltype(auto) dereference() const { return *impl_; }
   void increment() { ++impl_; }
@@ -56,14 +56,14 @@ protected:
 };
 
 template <typename It, typename Self>
-class proxy<It, Self, std::bidirectional_iterator_tag> : public facade<Self> {
+class Proxy<It, Self, std::bidirectional_iterator_tag> : public Facade<Self> {
 private:
   It impl_;
 
 public:
-  proxy() = default;
-  proxy(It impl) : impl_(impl) {}
-  template <typename... Args> proxy(Args &&... args) : impl_(FWD(args)...) {}
+  Proxy() = default;
+  Proxy(It impl) : impl_(impl) {}
+  template <typename... Args> Proxy(Args &&... args) : impl_(FWD(args)...) {}
 
   decltype(auto) dereference() const { return *impl_; }
   void increment() { ++impl_; }
@@ -80,7 +80,7 @@ protected:
 };
 
 template <typename It, typename Self>
-class proxy<It, Self, std::random_access_iterator_tag> : public facade<Self> {
+class Proxy<It, Self, std::random_access_iterator_tag> : public Facade<Self> {
 public:
   using difference_type = typename std::iterator_traits<It>::difference_type;
 
@@ -88,9 +88,9 @@ private:
   It impl_;
 
 public:
-  proxy() = default;
-  proxy(It impl) : impl_(impl) {}
-  template <typename... Args> proxy(Args &&... args) : impl_(FWD(args)...) {}
+  Proxy() = default;
+  Proxy(It impl) : impl_(impl) {}
+  template <typename... Args> Proxy(Args &&... args) : impl_(FWD(args)...) {}
 
   decltype(auto) dereference() const { return *impl_; }
   void advance(difference_type off) { impl_ += off; }

include/iterator/recursive_iterator.h

@@ -21,11 +21,10 @@
 #include <iterator/detail/macro.h>
 
 namespace iterator {
-template <typename Tuple, typename Projs, typename Indices>
-class recursive_iterator_base;
+template <typename Tuple, typename Projs, typename Indices> class RecursiveBase;
 template <typename... It, typename... Projs, size_t... Is>
-class recursive_iterator_base<std::tuple<It...>, detail::Projections<Projs...>,
-                              std::index_sequence<Is...>>
+class RecursiveBase<std::tuple<It...>, detail::Projections<Projs...>,
+                    std::index_sequence<Is...>>
     : public std::tuple<It...>, private detail::Projections<Projs...> {
 public:
   static constexpr size_t LastIndex = sizeof...(It) - 1;
@@ -34,8 +33,8 @@ public:
   template <size_t I> using value_type = std::iter_value_t<iterator_type<I>>;
 
 public:
-  template <typename T> operator end_aware_iterator<T>() const {
-    return std::get<end_aware_iterator<T>>(*this);
+  template <typename T> operator EndAwareIterator<T>() const {
+    return std::get<EndAwareIterator<T>>(*this);
   }
 
   decltype(auto) dereference() const {
@@ -54,13 +53,11 @@ public:
   void increment() { increment<>(); }
 
   bool at_end() const { return std::get<0>(*this).at_end(); }
-  bool equal_to(recursive_iterator_base const & other) const {
-    return *this == other;
-  }
+  bool equal_to(RecursiveBase const & other) const { return *this == other; }
 
 protected:
-  recursive_iterator_base() = default;
-  recursive_iterator_base(iterator_type<0> iter, Projs... projs)
+  RecursiveBase() = default;
+  RecursiveBase(iterator_type<0> iter, Projs... projs)
       : detail::Projections<Projs...>(projs...) {
     assign<0>(iter);
   }
@@ -95,7 +92,7 @@ private:
     }
   }
 
-  template <size_t I, typename T> void assign(end_aware_iterator<T> it) {
+  template <size_t I, typename T> void assign(EndAwareIterator<T> it) {
     std::get<I>(*this) = it;
     if constexpr (I < LastIndex) {
       if (!it.at_end()) {
@@ -106,7 +103,7 @@ private:
 
   template <size_t I, typename T> void assign(T && value) {
     if constexpr (Range<T>) {
-      assign<I>(end_aware_iterator(std::forward<T>(value)));
+      assign<I>(EndAwareIterator(std::forward<T>(value)));
     } else {
       assign<I>(std::get<1>(value));
     }
@@ -115,7 +112,7 @@ private:
 
 template <typename It, typename MaxDepth,
           typename Projs = detail::Projections<>>
-struct recursive_iterator_helper {
+struct RecursiveHelper {
   static typename detail::ProjectionExpander<It, Projs>::type const & _projs;
   using Projections = decltype(detail::Projections(_projs));
 
@@ -125,7 +122,7 @@ struct recursive_iterator_helper {
   static constexpr auto extent = std::tuple_size_v<iterator_tuple>;
   using indices = decltype(std::make_index_sequence<extent>());
 
-  using type = recursive_iterator_base<iterator_tuple, Projections, indices>;
+  using type = RecursiveBase<iterator_tuple, Projections, indices>;
 };
 
 /**
@@ -143,39 +140,39 @@ struct recursive_iterator_helper {
  * iterator is willing to delve in the parent object.
  */
 template <typename It, typename MaxDepth>
-class recursive_iterator : public recursive_iterator_helper<It, MaxDepth>::type,
-                           public facade<recursive_iterator<It, MaxDepth>> {
+class RecursiveIterator : public RecursiveHelper<It, MaxDepth>::type,
+                          public Facade<RecursiveIterator<It, MaxDepth>> {
 public:
   using sentinel_type = sentinel_t;
 
 public:
-  recursive_iterator() = default;
+  RecursiveIterator() = default;
 
-  explicit recursive_iterator(Range auto & range, MaxDepth = {})
-      : recursive_iterator(end_aware_iterator(range)) {}
+  explicit RecursiveIterator(Range auto & range, MaxDepth = {})
+      : RecursiveIterator(EndAwareIterator(range)) {}
 
-  explicit recursive_iterator(end_aware_iterator<It> iter, MaxDepth = {})
-      : recursive_iterator::recursive_iterator_base(iter) {}
+  explicit RecursiveIterator(EndAwareIterator<It> iter, MaxDepth = {})
+      : RecursiveIterator::RecursiveBase(iter) {}
 
   template <typename Ot>
-  explicit recursive_iterator(end_aware_iterator<Ot> other, MaxDepth = {})
-      : recursive_iterator(end_aware_iterator<It>(other)) {}
+  explicit RecursiveIterator(EndAwareIterator<Ot> other, MaxDepth = {})
+      : RecursiveIterator(EndAwareIterator<It>(other)) {}
 
   template <typename Ot>
-  explicit recursive_iterator(recursive_iterator<Ot, MaxDepth> other)
-      : recursive_iterator(end_aware_iterator<Ot>(other)) {}
+  explicit RecursiveIterator(RecursiveIterator<Ot, MaxDepth> other)
+      : RecursiveIterator(EndAwareIterator<Ot>(other)) {}
 };
 
 template <typename Range, typename MaxDepth>
-recursive_iterator(Range &, MaxDepth)
-    -> recursive_iterator<iterator_t<Range>, MaxDepth>;
+RecursiveIterator(Range &, MaxDepth)
+    -> RecursiveIterator<iterator_t<Range>, MaxDepth>;
 template <typename Range>
-recursive_iterator(Range &) -> recursive_iterator<iterator_t<Range>, unbounded>;
+RecursiveIterator(Range &) -> RecursiveIterator<iterator_t<Range>, unbounded>;
 } // namespace iterator
 
 namespace std {
 template <size_t I, typename It, typename MaxDepth>
-auto get(::iterator::recursive_iterator<It, MaxDepth> const & iter) {
+auto get(::iterator::RecursiveIterator<It, MaxDepth> const & iter) {
   using return_type = std::decay_t<decltype(iter)>::template iterator_type<I>;
   return static_cast<return_type>(iter);
 }
@@ -185,14 +182,14 @@ namespace iterator::views {
 template <size_t N>
 struct recursive_n_fn : std::ranges::range_adaptor_closure<recursive_n_fn<N>> {
   template <std::ranges::range Rng> auto operator()(Rng && rng) const {
-    auto begin = recursive_iterator(std::forward<Rng>(rng), bounded<N>{});
+    auto begin = RecursiveIterator(std::forward<Rng>(rng), bounded<N>{});
     return std::ranges::subrange(begin, decltype(begin)());
   }
 };
 
 struct recursive_fn : std::ranges::range_adaptor_closure<recursive_fn> {
   template <std::ranges::range Rng> auto operator()(Rng && rng) const {
-    auto begin = recursive_iterator(std::forward<Rng>(rng));
+    auto begin = RecursiveIterator(std::forward<Rng>(rng));
     return std::ranges::subrange(begin, decltype(begin)());
   }
 };

include/iterator/unkeyed_iterator.h

@@ -20,16 +20,16 @@ namespace iterator {
  * have something crazy like a four-level map and then do:
  * \code
  * std::map<int, std::map<std::string, std::map<int, BigType>>> object;
- * auto const rit = recursive_iterator(object);
- * for (unkeyed_iterator<decltype(rit)> it = rit, end = {}; it != end; ++it) {
+ * auto const rit = RecursiveIterator(object);
+ * for (ValuesIterator<decltype(rit)> it = rit, end = {}; it != end; ++it) {
  *   // Process only BigType, discarding all of the keys that we need to walk
  * }
  * \endcode
  */
 template <typename Iterator>
-class unkeyed_iterator : public proxy<Iterator, unkeyed_iterator<Iterator>> {
+class ValuesIterator : public Proxy<Iterator, ValuesIterator<Iterator>> {
 public:
-  using proxy<Iterator, unkeyed_iterator<Iterator>>::proxy;
+  using Proxy<Iterator, ValuesIterator<Iterator>>::Proxy;
   decltype(auto) dereference() const {
     using value_type = typename Iterator::value_type;
     constexpr auto index = std::tuple_size<value_type>::value - 1;
@@ -37,5 +37,5 @@ public:
   }
 };
 
-template <typename It> unkeyed_iterator(It) -> unkeyed_iterator<It>;
+template <typename It> ValuesIterator(It) -> ValuesIterator<It>;
 }

include/iterator/zip_iterator.h

@@ -60,12 +60,12 @@ using zip_impl =
     detail::zip_iterator_impl<std::tuple<Ts...>, index_sequence<Ts...>>;
 
 template <typename... Iters>
-class zip_iterator : public zip_impl<Iters...>,
-                     public facade<zip_iterator<Iters...>> {
+class ZipIterator : public zip_impl<Iters...>,
+                    public Facade<ZipIterator<Iters...>> {
 public:
-  zip_iterator() = default;
-  zip_iterator(Iters... iters) : zip_impl<Iters...>(iters...) {}
+  ZipIterator() = default;
+  ZipIterator(Iters... iters) : zip_impl<Iters...>(iters...) {}
 };
 
-template <typename... It> zip_iterator(It...) -> zip_iterator<It...>;
+template <typename... It> ZipIterator(It...) -> ZipIterator<It...>;
 }

test/cascade_iterator_test.cxx

@@ -11,7 +11,7 @@
 #include "ranges.h"
 #include "xcode_gtest_helper.h"
 
-using iterator::cascade_iterator;
+using iterator::ProjectingRecursiveIterator;
 
 struct Baz {
   std::vector<int> ints;
@@ -33,27 +33,28 @@ struct Foo {
 
 TEST(CascadeIteratorTest, OneProjectorIsTwoLevels) {
   std::vector<Foo> foos;
-  auto iter = cascade_iterator(foos, &Foo::bars);
+  auto iter = ProjectingRecursiveIterator(foos, &Foo::bars);
   testing::StaticAssertTypeEq<decltype(*iter), Bar const &>();
 }
 
 TEST(CascadeIteratorTest, TwoProjectorIsThreeLevels) {
   std::vector<Foo> foos;
-  auto iter = cascade_iterator(foos, &Foo::bars, &Bar::bazes);
+  auto iter = ProjectingRecursiveIterator(foos, &Foo::bars, &Bar::bazes);
   testing::StaticAssertTypeEq<decltype(*iter),
                               std::tuple<int const &, Baz const &>>();
 }
 
 TEST(CascadeIteratorTest, IsRvalueSafe) {
   std::vector<Foo> foos;
-  auto iter = cascade_iterator(foos, &Foo::bars_copy, &Bar::bazes);
+  auto iter = ProjectingRecursiveIterator(foos, &Foo::bars_copy, &Bar::bazes);
   testing::StaticAssertTypeEq<decltype(*iter),
                               std::tuple<int const &, Baz const &>>();
 }
 
 TEST(CascadeIteratorTest, CanProjectUnboundedTail) {
   std::vector<Foo> foos;
-  auto iter = cascade_iterator(foos, iterator::unbounded{}, &Foo::example);
+  auto iter =
+      ProjectingRecursiveIterator(foos, iterator::unbounded{}, &Foo::example);
   static_assert(
       std::same_as<decltype(*iter),
                    std::tuple<int const &, std::string const &, int &>>);
@@ -63,7 +64,8 @@ TEST(CascadeIteratorTest, CanProjectUnboundedTail) {
 
 TEST(CascadeIteratorTest, CanProjectBoundedTail) {
   std::vector<Foo> foos;
-  auto iter = cascade_iterator(foos, iterator::bounded<3>{}, &Foo::example);
+  auto iter =
+      ProjectingRecursiveIterator(foos, iterator::bounded<3>{}, &Foo::example);
   static_assert(
       std::same_as<decltype(*iter),
                    std::tuple<int const &, std::string const &, int &>>);

test/end_aware_iterator_test.cxx

@@ -5,12 +5,12 @@
 
 #include "xcode_gtest_helper.h"
 
-using iterator::end_aware_iterator;
+using iterator::EndAwareIterator;
 
 TEST(EndAwareIterator, IStreamIterator) {
   std::stringstream ss{"0 1 2 3"};
-  end_aware_iterator eai{std::istream_iterator<int>(ss),
-                         std::istream_iterator<int>()};
+  EndAwareIterator eai{std::istream_iterator<int>(ss),
+                       std::istream_iterator<int>()};
 
   EXPECT_TRUE(iterator::single_pass<decltype(eai)>);
 }
@@ -18,40 +18,40 @@ TEST(EndAwareIterator, IStreamIterator) {
 // TODO: This ought to be implemented as a compiles-test
 TEST(EndAwareIterator, CanCastCompatibleIterators) {
   std::vector<int> v{1, 2, 3, 4, 5};
-  end_aware_iterator eai(v.begin(), v.end());
+  EndAwareIterator eai(v.begin(), v.end());
 
-  end_aware_iterator<std::vector<int>::const_iterator>{eai};
+  EndAwareIterator<std::vector<int>::const_iterator>{eai};
 }
 
 TEST(EndAwareIterator, BeginWrapperIsEqualToBegin) {
   std::vector<int> v{1, 2, 3, 4, 5};
 
-  EXPECT_EQ(*v.begin(), *end_aware_iterator(v.begin(), v.end()));
+  EXPECT_EQ(*v.begin(), *EndAwareIterator(v.begin(), v.end()));
 }
 
 TEST(EndAwareIterator, MutableActionsArePassthrough) {
   std::vector<int> v{1, 2, 3, 4, 5};
-  *end_aware_iterator(v.begin(), v.end()) = -1;
+  *EndAwareIterator(v.begin(), v.end()) = -1;
 
   EXPECT_EQ(v[0], -1);
 }
 
 TEST(EndAwareIterator, CanTellYouThatItsReachedEnd) {
   std::vector<int> v{1, 2, 3, 4, 5};
-  end_aware_iterator it{v.end() - 1, v.end()};
+  EndAwareIterator it{v.end() - 1, v.end()};
   EXPECT_FALSE(it.at_end());
   ++it;
-  EXPECT_EQ(it, end_aware_iterator(v.end(), v.end()));
+  EXPECT_EQ(it, EndAwareIterator(v.end(), v.end()));
   EXPECT_TRUE(it.at_end());
 }
 
 TEST(EndAwareIterator, EmptyIteratorIsEnd) {
-  EXPECT_TRUE(end_aware_iterator<std::vector<int>::iterator>().at_end());
+  EXPECT_TRUE(EndAwareIterator<std::vector<int>::iterator>().at_end());
 }
 
 TEST(EndAwareIterator, PreIncrementAdvancesIterator) {
   std::vector<int> v{1, 2, 3, 4, 5};
-  end_aware_iterator eai(v.begin(), v.end());
+  EndAwareIterator eai(v.begin(), v.end());
 
   EXPECT_EQ(*eai, 1);
   EXPECT_EQ(*++eai, 2);
@@ -60,7 +60,7 @@ TEST(EndAwareIterator, PreIncrementAdvancesIterator) {
 
 TEST(EndAwareIterator, PostIncrementReturnsCopyOfPrev) {
   std::vector<int> v{1, 2, 3, 4, 5};
-  end_aware_iterator eai(v.begin(), v.end());
+  EndAwareIterator eai(v.begin(), v.end());
 
   EXPECT_EQ(*eai, 1);
   EXPECT_EQ(*eai++, 1);
@@ -70,7 +70,7 @@ TEST(EndAwareIterator, PostIncrementReturnsCopyOfPrev) {
 TEST(EndAwareIterator, CanIterateWithSentinel) {
   std::vector<int> v{1, 2, 3, 4, 5};
   size_t count{0};
-  for (end_aware_iterator it(v); it != iterator::sentinel; ++it) {
+  for (EndAwareIterator it(v); it != iterator::sentinel; ++it) {
     ++count;
   }
 

test/filter_iterator_test.cxx

@@ -5,13 +5,13 @@
 #include "ranges.h"
 #include "xcode_gtest_helper.h"
 
-using iterator::filter_iterator;
+using iterator::FilterIterator;
 
 bool is_even(int i) { return i % 2 == 0; }
 
 TEST(FilterIterator, CanPerformSkipsOnData) {
   std::vector<int> const data = {1, 2, 3, 4, 5};
-  filter_iterator it(data, is_even);
+  FilterIterator it(data, is_even);
 
   EXPECT_EQ(ranges::distance(it, iterator::sentinel), 2);
   EXPECT_EQ(*it++, 2);
@@ -21,7 +21,7 @@ TEST(FilterIterator, CanPerformSkipsOnData) {
 // TODO: Maybe this should actually move
 TEST(FilterIterator, MutatingContainerDoesNotMoveIterator) {
   std::vector<int> data = {1, 2, 3, 4, 5};
-  filter_iterator it(data, is_even);
+  FilterIterator it(data, is_even);
 
   EXPECT_EQ(ranges::distance(it, iterator::sentinel), 2);
 
@@ -32,21 +32,21 @@ TEST(FilterIterator, MutatingContainerDoesNotMoveIterator) {
 
 TEST(FilterIterator, CanConstructFilterFromSubRange) {
   std::vector<int> data = {1, 2, 3, 4, 5};
-  filter_iterator it(data.begin(), data.begin() + 3, is_even);
+  FilterIterator it(data.begin(), data.begin() + 3, is_even);
 
   EXPECT_EQ(ranges::distance(it, iterator::sentinel), 1);
 }
 
 TEST(FilterIterator, IfNonMatchThenStartIsEnd) {
   std::vector<int> const data = {1, 3, 5};
-  filter_iterator it(data, is_even);
+  FilterIterator it(data, is_even);
 
   EXPECT_EQ(it, iterator::sentinel);
 }
 
 TEST(FilterIterator, CapsIterationAtEnd) {
   std::vector<int> const data = {1, 2, 3, 4, 5};
-  filter_iterator it(data, is_even);
+  FilterIterator it(data, is_even);
 
   ++ ++it;
   EXPECT_EQ(it, iterator::sentinel);
@@ -58,7 +58,7 @@ TEST(FilterIterator, CapsIterationAtEnd) {
 TEST(FilterIterator, CanIterateWithSentinel) {
   std::vector<int> v{1, 2, 3, 4, 5};
   size_t count{0};
-  for (filter_iterator it(v, is_even); it != iterator::sentinel; ++it) {
+  for (FilterIterator it(v, is_even); it != iterator::sentinel; ++it) {
     ++count;
   }
 

test/indexed_iterator_test.cxx

@@ -8,7 +8,7 @@
 #include "ranges.h"
 #include "xcode_gtest_helper.h"
 
-using iterator::end_aware_iterator;
+using iterator::EndAwareIterator;
 using iterator::indexed_iterator;
 
 using testing::Ge;
@@ -45,7 +45,7 @@ TEST(IndexedIteratorTest, DoesNotTrackByIndex) {
 
 TEST(IndexedIteratorTest, IteratorPropagatesAtEnd) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
-  indexed_iterator end(end_aware_iterator(vec.end(), vec.end()));
+  indexed_iterator end(EndAwareIterator(vec.end(), vec.end()));
 
   EXPECT_EQ(end, iterator::sentinel);
 }

test/join_iterator_test.cxx

@@ -4,51 +4,51 @@
 
 #include "xcode_gtest_helper.h"
 
-using iterator::end_aware_iterator;
-using iterator::joining_iterator;
+using iterator::EndAwareIterator;
+using iterator::JoinIterator;
 
 TEST(JoinIteratorTest, FirstDereferencedElemIsTheFirstInTheChain) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
-  EXPECT_EQ(*joining_iterator(mv), mv[0][0]);
+  EXPECT_EQ(*JoinIterator(mv), mv[0][0]);
 }
 
 TEST(JoinIteratorTest, HoldsReferenceToContainedElements) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
-  EXPECT_EQ(joining_iterator(mv).operator->(), &mv[0][0]);
+  EXPECT_EQ(JoinIterator(mv).operator->(), &mv[0][0]);
 }
 
 TEST(JoinIteratorTest, EmptyContainerBeginIsEnd) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
-  joining_iterator it(mv);
+  JoinIterator it(mv);
   EXPECT_NE(it, iterator::sentinel);
 
   mv.clear();
-  EXPECT_EQ(joining_iterator(mv), iterator::sentinel);
+  EXPECT_EQ(JoinIterator(mv), iterator::sentinel);
 }
 
 // TODO: This ought to be implemented as a compiles-test
 TEST(JoinIteratorTest, CanCastCompatibleIterators) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
-  joining_iterator it(mv);
-  iterator::joining_iterator<decltype(mv)::const_iterator>{it};
+  JoinIterator it(mv);
+  iterator::JoinIterator<decltype(mv)::const_iterator>{it};
 }
 
 TEST(JoinIteratorTest, CanAccessInternalIterator) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
-  auto eai = end_aware_iterator(mv);
-  joining_iterator it(eai);
+  auto eai = EndAwareIterator(mv);
+  JoinIterator it(eai);
   EXPECT_EQ(it.outer_iterator(), eai);
 }
 
 TEST(JoinIteratorTest, CanAccessChildIterator) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
-  joining_iterator it(mv);
-  EXPECT_EQ(it.inner_iterator(), end_aware_iterator(mv[0]));
+  JoinIterator it(mv);
+  EXPECT_EQ(it.inner_iterator(), EndAwareIterator(mv[0]));
 }
 
 TEST(JoinIteratorTest, PreIncrementAdvancesIterator) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
-  joining_iterator it(mv);
+  JoinIterator it(mv);
   EXPECT_EQ(*it, 1);
   EXPECT_EQ(*++it, 2);
   EXPECT_EQ(*it, 2);
@@ -56,7 +56,7 @@ TEST(JoinIteratorTest, PreIncrementAdvancesIterator) {
 
 TEST(JoinIteratorTest, PostIncrementReturnsCopyOfPrev) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
-  joining_iterator it(mv);
+  JoinIterator it(mv);
   EXPECT_EQ(*it, 1);
   EXPECT_EQ(*it++, 1);
   EXPECT_EQ(*it, 2);
@@ -64,14 +64,14 @@ TEST(JoinIteratorTest, PostIncrementReturnsCopyOfPrev) {
 
 TEST(JoinIteratorTest, MovesFromListToListWhenReachingEnd) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
-  joining_iterator it(mv);
+  JoinIterator it(mv);
   std::advance(it, 2);
   EXPECT_EQ(*++it, mv[1][0]);
 }
 
 TEST(JoinIteratorTest, SkipsOverEmptyElements) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {}, {4, 5, 6}};
-  joining_iterator it(mv);
+  JoinIterator it(mv);
   std::advance(it, 2);
   EXPECT_EQ(*++it, mv[2][0]);
 }

test/recursive_iterator_accessors_test.cxx

@@ -9,8 +9,8 @@
 #include "xcode_gtest_helper.h"
 
 using iterator::bounded;
-using iterator::end_aware_iterator;
-using iterator::recursive_iterator;
+using iterator::EndAwareIterator;
+using iterator::RecursiveIterator;
 
 using testing::ElementsAreArray;
 using testing::Not;
@@ -18,7 +18,7 @@ using testing::StaticAssertTypeEq;
 
 TEST(RecursiveIteratorTest, DoesNotUnwrapString) {
   std::vector<std::string> obj{"A", "B", "C", "D"};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
   StaticAssertTypeEq<decltype(rit.operator->()), std::string *>();
 
   EXPECT_THAT(obj | views::recursive | ranges::to<std::vector>(),
@@ -27,24 +27,24 @@ TEST(RecursiveIteratorTest, DoesNotUnwrapString) {
 
 TEST(RecursiveIteratorTest, CanArrowMultiVector) {
   std::vector<std::vector<int>> obj{{{0, 1}}, {{2, 3}}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
   StaticAssertTypeEq<decltype(rit.operator->()), int *>();
   EXPECT_THAT(rit.operator->(), &obj[0][0]);
 }
 
 TEST(RecursiveIteratorTest, CanAccessOuterterator) {
   std::map<int, std::vector<int>> obj{{1, {{0, 1}}}, {2, {{2, 3}}}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
 
-  end_aware_iterator<decltype(obj)::iterator> inner = rit;
+  EndAwareIterator<decltype(obj)::iterator> inner = rit;
   EXPECT_THAT(&std::get<0>(*rit), &(inner->first));
 }
 
 TEST(RecursiveIteratorTest, CanAccessInnerIterator) {
   std::map<int, std::vector<int>> obj{{1, {{0, 1}}}, {2, {{2, 3}}}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
 
-  end_aware_iterator<std::vector<int>::iterator> inner = rit;
+  EndAwareIterator<std::vector<int>::iterator> inner = rit;
   EXPECT_THAT(&std::get<1>(*rit), &*inner);
 }
 
@@ -53,19 +53,19 @@ TEST(RecursiveIteratorTest, CanStdGetToAllLayersOfInternalIteration) {
       {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
 
   using mvm_iterator = std::map<int, std::vector<std::map<int, int>>>::iterator;
   StaticAssertTypeEq<decltype(std::get<0>(rit)),
-                     end_aware_iterator<mvm_iterator>>();
+                     EndAwareIterator<mvm_iterator>>();
 
   using vm_iterator = std::vector<std::map<int, int>>::iterator;
   StaticAssertTypeEq<decltype(std::get<1>(rit)),
-                     end_aware_iterator<vm_iterator>>();
+                     EndAwareIterator<vm_iterator>>();
 
   using m_iterator = std::map<int, int>::iterator;
   StaticAssertTypeEq<decltype(std::get<2>(rit)),
-                     end_aware_iterator<m_iterator>>();
+                     EndAwareIterator<m_iterator>>();
 
   using tup_i_i_i = std::tuple<int const &, int const &, int &>;
   StaticAssertTypeEq<decltype(*rit), tup_i_i_i>();
@@ -76,10 +76,10 @@ TEST(RecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
       {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
-  auto rit = recursive_iterator(obj);
-  EXPECT_THAT(std::get<0>(rit), end_aware_iterator(obj));
-  EXPECT_THAT(std::get<1>(rit), end_aware_iterator(obj[1]));
-  EXPECT_THAT(std::get<2>(rit), end_aware_iterator(obj[1][0]));
+  auto rit = RecursiveIterator(obj);
+  EXPECT_THAT(std::get<0>(rit), EndAwareIterator(obj));
+  EXPECT_THAT(std::get<1>(rit), EndAwareIterator(obj[1]));
+  EXPECT_THAT(std::get<2>(rit), EndAwareIterator(obj[1][0]));
 }
 
 // TODO: This ought to be implemented as a compiles-test
@@ -88,8 +88,8 @@ TEST(RecursiveIteratorTest, CanCastCompatibleIterators) {
       {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
-  auto rit = recursive_iterator(obj);
-  iterator::recursive_iterator<decltype(obj)::const_iterator> cit(rit);
+  auto rit = RecursiveIterator(obj);
+  iterator::RecursiveIterator<decltype(obj)::const_iterator> cit(rit);
 }
 
 TEST(RecursiveIteratorTest, EmptyCtorIsEnd) {
@@ -97,7 +97,7 @@ TEST(RecursiveIteratorTest, EmptyCtorIsEnd) {
       {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
 
   EXPECT_THAT(rit, Not(iterator::sentinel));
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 4);
@@ -111,15 +111,15 @@ TEST(BoundedRecursiveIteratorTest, CanStdGetToNLayersOfInternalIteration) {
       {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
-  auto rit = recursive_iterator(obj, bounded<2>{});
+  auto rit = RecursiveIterator(obj, bounded<2>{});
 
   using mvm_iterator = std::map<int, std::vector<std::map<int, int>>>::iterator;
   StaticAssertTypeEq<decltype(std::get<0>(rit)),
-                     end_aware_iterator<mvm_iterator>>();
+                     EndAwareIterator<mvm_iterator>>();
 
   using vm_iterator = std::vector<std::map<int, int>>::iterator;
   StaticAssertTypeEq<decltype(std::get<1>(rit)),
-                     end_aware_iterator<vm_iterator>>();
+                     EndAwareIterator<vm_iterator>>();
 
   using tup_i_mii = std::tuple<int const &, std::map<int, int> &>;
   StaticAssertTypeEq<decltype(*rit), tup_i_mii>();
@@ -130,9 +130,9 @@ TEST(BoundedRecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
       {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
-  auto rit = recursive_iterator(obj, bounded<2>{});
-  EXPECT_THAT(std::get<0>(rit), end_aware_iterator(obj));
-  EXPECT_THAT(std::get<1>(rit), end_aware_iterator(obj[1]));
+  auto rit = RecursiveIterator(obj, bounded<2>{});
+  EXPECT_THAT(std::get<0>(rit), EndAwareIterator(obj));
+  EXPECT_THAT(std::get<1>(rit), EndAwareIterator(obj[1]));
 }
 
 // TODO: This ought to be implemented as a compiles-test
@@ -141,8 +141,8 @@ TEST(BoundedRecursiveIteratorTest, CanCastCompatibleIterators) {
       {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
-  auto rit = recursive_iterator(obj, bounded<2>{});
-  iterator::recursive_iterator_n<decltype(obj)::const_iterator, 2> cit(rit);
+  auto rit = RecursiveIterator(obj, bounded<2>{});
+  iterator::RecursiveIteratorN<decltype(obj)::const_iterator, 2> cit(rit);
 }
 
 TEST(BoundedRecursiveIteratorTest, EmptyCtorIsEnd) {
@@ -150,7 +150,7 @@ TEST(BoundedRecursiveIteratorTest, EmptyCtorIsEnd) {
       {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
-  auto rit = recursive_iterator(obj, bounded<3>{});
+  auto rit = RecursiveIterator(obj, bounded<3>{});
   EXPECT_THAT(rit, Not(iterator::sentinel));
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 4);
 
@@ -163,6 +163,6 @@ TEST(BoundedRecursiveIteratorTest, CanFetchInnerCollections) {
       {{{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
       {{{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
-  auto rit = recursive_iterator(obj, bounded<2>{});
+  auto rit = RecursiveIterator(obj, bounded<2>{});
   EXPECT_THAT(*rit, obj[0][0]);
 }

test/recursive_iterator_map_test.cxx

@@ -11,7 +11,7 @@
 #include "xcode_gtest_helper.h"
 
 using iterator::bounded;
-using iterator::recursive_iterator;
+using iterator::RecursiveIterator;
 
 using testing::ElementsAreArray;
 using testing::IsEmpty;
@@ -19,7 +19,7 @@ using testing::IsEmpty;
 TEST(RecursiveIteratorMapTest, PreIncrementAdvancesIterator) {
   std::map<int, std::map<int, std::map<int, int>>> const map{
       {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
-  auto rit = recursive_iterator(map);
+  auto rit = RecursiveIterator(map);
   EXPECT_THAT(std::get<3>(*rit), 1);
   EXPECT_THAT(std::get<3>(*++rit), 2);
   EXPECT_THAT(std::get<3>(*rit), 2);
@@ -28,7 +28,7 @@ TEST(RecursiveIteratorMapTest, PreIncrementAdvancesIterator) {
 TEST(RecursiveIteratorMapTest, PostIncrementReturnsCopyOfPrev) {
   std::map<int, std::map<int, std::map<int, int>>> const map{
       {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
-  auto rit = recursive_iterator(map);
+  auto rit = RecursiveIterator(map);
   EXPECT_THAT(std::get<3>(*rit), 1);
   EXPECT_THAT(std::get<3>(*rit++), 1);
   EXPECT_THAT(std::get<3>(*rit), 2);
@@ -37,7 +37,7 @@ TEST(RecursiveIteratorMapTest, PostIncrementReturnsCopyOfPrev) {
 TEST(RecursiveIteratorMapTest, IterDistanceIsSumOfInnerContainerSizes) {
   std::map<int, std::map<int, std::map<int, int>>> const map{
       {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
-  auto rit = recursive_iterator(map);
+  auto rit = RecursiveIterator(map);
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 4);
 }
@@ -55,7 +55,7 @@ TEST(RecursiveIteratorMapTest, ElementsAreUnwrappedAsATuple) {
 TEST(RecursiveIteratorMapTest, CanMutatePointedToData) {
   std::map<int, std::map<int, std::map<int, int>>> map{
       {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
-  auto rit = recursive_iterator(map);
+  auto rit = RecursiveIterator(map);
   std::get<3>(*rit) = 4;
   EXPECT_THAT(map[1][1][1], 4);
 }
@@ -63,7 +63,7 @@ TEST(RecursiveIteratorMapTest, CanMutatePointedToData) {
 TEST(BoundRecursiveIteratorMapTest, PreIncrementAdvancesIterator) {
   std::map<int, std::map<int, std::map<int, int>>> map{
       {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
-  auto rit = recursive_iterator(map, bounded<2>{});
+  auto rit = RecursiveIterator(map, bounded<2>{});
   EXPECT_THAT(std::get<2>(*rit), map[1][1]);
   EXPECT_THAT(std::get<2>(*++rit), map[2][2]);
   EXPECT_THAT(std::get<2>(*rit), map[2][2]);
@@ -72,7 +72,7 @@ TEST(BoundRecursiveIteratorMapTest, PreIncrementAdvancesIterator) {
 TEST(BoundRecursiveIteratorMapTest, PostIncrementReturnsCopyOfPrev) {
   std::map<int, std::map<int, std::map<int, int>>> map{
       {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
-  auto rit = recursive_iterator(map, bounded<2>{});
+  auto rit = RecursiveIterator(map, bounded<2>{});
   EXPECT_THAT(std::get<2>(*rit), map[1][1]);
   EXPECT_THAT(std::get<2>(*rit++), map[1][1]);
   EXPECT_THAT(std::get<2>(*rit), map[2][2]);
@@ -81,7 +81,7 @@ TEST(BoundRecursiveIteratorMapTest, PostIncrementReturnsCopyOfPrev) {
 TEST(BoundRecursiveIteratorMapTest, IterDistanceSumOnNLayersSize) {
   std::map<int, std::map<int, std::map<int, int>>> const map{
       {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
-  auto rit = recursive_iterator(map, bounded<2>{});
+  auto rit = RecursiveIterator(map, bounded<2>{});
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 3);
 }
@@ -99,7 +99,7 @@ TEST(BoundRecursiveIteratorMapTest, ElementsAreUnwrappedAsATuple) {
 TEST(BoundedRecursiveIteratorMapTest, CanMutatePointedToData) {
   std::map<int, std::map<int, std::map<int, int>>> map{
       {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
-  auto rit = recursive_iterator(map, bounded<2>{});
+  auto rit = RecursiveIterator(map, bounded<2>{});
   std::get<2>(*rit).clear();
   EXPECT_THAT(map[1][1], IsEmpty());
 }

test/recursive_iterator_mixed_container_test.cxx

@@ -6,13 +6,13 @@
 #include "ranges.h"
 #include "xcode_gtest_helper.h"
 
-using iterator::recursive_iterator;
+using iterator::RecursiveIterator;
 
 using testing::ElementsAreArray;
 
 TEST(RecursiveIteratorMapVectorTest, IterDistanceIsSumOfInnerContainerSizes) {
   std::map<int, std::vector<int>> const obj{{1, {1, 2}}, {2, {3, 4, 5}}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 5);
 }
@@ -28,7 +28,7 @@ TEST(RecursiveIteratorMapVectorTest, ElementsAreUnwrappedAsATuple) {
 
 TEST(RecursiveIteratorMapVectorTest, CanMutatePointedToData) {
   std::map<int, std::vector<int>> obj{{1, {1, 2}}, {2, {3, 4, 5}}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
   std::get<1>(*rit) = 6;
   EXPECT_THAT(obj[1][0], 6);
 }
@@ -36,7 +36,7 @@ TEST(RecursiveIteratorMapVectorTest, CanMutatePointedToData) {
 TEST(RecursiveIteratorMapMapVectorTest, CanMutatePointedToData) {
   std::map<int, std::map<int, std::vector<int>>> obj{{1, {{1, {1, 2}}}},
                                                      {2, {{1, {3, 4, 5}}}}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
   std::get<2>(*rit) = 6;
   EXPECT_THAT(obj[1][1][0], 6);
 }
@@ -44,7 +44,7 @@ TEST(RecursiveIteratorMapMapVectorTest, CanMutatePointedToData) {
 TEST(RecursiveIteratorVectorMapTest, IterDistanceIsSumOfInnerContainerSizes) {
   std::vector<std::map<int, int>> const obj{{{1, 1}, {2, 2}},
                                             {{3, 3}, {4, 4}, {5, 5}}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 5);
 }
@@ -62,7 +62,7 @@ TEST(RecursiveIteratorVectorMapTest, ElementsAreUnwrappedAsATuple) {
 TEST(RecursiveIteratorVectorMapTest, CanMutatePointedToData) {
   std::vector<std::map<int, int>> obj{{{1, 1}, {2, 2}},
                                       {{3, 3}, {4, 4}, {5, 5}}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
   std::get<1>(*rit) = 6;
   EXPECT_THAT(obj[0][1], 6);
 }
@@ -71,7 +71,7 @@ TEST(RecursiveIteratorMapVecMapTest, IterDistanceIsSumOfInnerContainerSizes) {
   std::map<int, std::vector<std::map<int, int>>> const obj{
       {1, {{{1, 1}, {2, 2}}}}};
   std::vector<std::tuple<int, int, int>> const expected{{1, 1, 1}, {1, 2, 2}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), expected.size());
 }
@@ -87,7 +87,7 @@ TEST(RecursiveIteratorMapVecMapTest, ElementsAreUnwrappedAsATuple) {
 
 TEST(RecursiveIteratorMapVecMapTest, CanMutatePointedToData) {
   std::map<int, std::vector<std::map<int, int>>> obj{{1, {{{1, 1}, {2, 2}}}}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
   std::get<2>(*rit) = 4;
   EXPECT_THAT(obj[1][0][1], 4);
 }
@@ -95,7 +95,7 @@ TEST(RecursiveIteratorMapVecMapTest, CanMutatePointedToData) {
 TEST(RecursiveIteratorVecMapVecTest, IterDistanceIsSumOfInnerContainerSizes) {
   std::vector<std::map<int, std::vector<int>>> const obj{
       {{1, {1, 2}}, {2, {3, 4, 5}}}, {{1, {3, 4}}}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 7);
 }
@@ -113,7 +113,7 @@ TEST(RecursiveIteratorVecMapVecTest, ElementsAreUnwrappedAsATuple) {
 TEST(RecursiveIteratorVecMapVecTest, CanMutatePointedToData) {
   std::vector<std::map<int, std::vector<int>>> obj{
       {{1, {1, 2}}, {2, {3, 4, 5}}}, {{1, {3, 4}}}};
-  auto rit = recursive_iterator(obj);
+  auto rit = RecursiveIterator(obj);
   std::get<1>(*rit) = 6;
 
   EXPECT_THAT(obj[0][1][0], 6);

test/recursive_iterator_single_level_test.cxx

@@ -14,13 +14,13 @@
 #include "ranges.h"
 #include "xcode_gtest_helper.h"
 
-using iterator::recursive_iterator;
+using iterator::RecursiveIterator;
 
 using testing::ElementsAreArray;
 
 TEST(RecursiveIteratorSingleVectorTest, IterDistanceIsContainerSize) {
   std::vector<int> const vec{1, 2, 3, 4, 5};
-  auto rit = recursive_iterator(vec);
+  auto rit = RecursiveIterator(vec);
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), vec.size());
 }
@@ -34,14 +34,14 @@ TEST(RecursiveIteratorSingleVectorTest, DataMatchesContainerIterator) {
 
 TEST(RecursiveIteratorSingleVectorTest, CanMutatePointedToData) {
   std::vector<int> vec{1, 2, 3, 4, 5};
-  auto rit = recursive_iterator(vec);
+  auto rit = RecursiveIterator(vec);
   *rit = 6;
   EXPECT_THAT(vec[0], 6);
 }
 
 TEST(RecursiveIteratorSingleMapTest, IterDistanceIsContainerSize) {
   std::map<int, int> const map{{1, 1}, {2, 2}, {3, 3}};
-  auto rit = recursive_iterator(map);
+  auto rit = RecursiveIterator(map);
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), map.size());
 }
@@ -54,7 +54,7 @@ TEST(RecursiveIteratorSingleMapTest, DataMatchesContainerIterator) {
 
 TEST(RecursiveIteratorSingleMapTest, CanMutatePointedToData) {
   std::map<int, int> map{{1, 1}, {2, 2}, {3, 3}};
-  auto rit = recursive_iterator(map);
+  auto rit = RecursiveIterator(map);
   std::get<1>(*rit) = 4;
   EXPECT_THAT(map[1], 4);
 }

test/recursive_iterator_vector_test.cxx

@@ -8,14 +8,14 @@
 #include "xcode_gtest_helper.h"
 
 using iterator::bounded;
-using iterator::recursive_iterator;
+using iterator::RecursiveIterator;
 
 using testing::ElementsAreArray;
 using testing::IsEmpty;
 
 TEST(RecursiveIteratorVecTest, PreIncrementAdvancesIterator) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
-  auto rit = recursive_iterator(vec);
+  auto rit = RecursiveIterator(vec);
   EXPECT_THAT(*rit, 1);
   EXPECT_THAT(*++rit, 2);
   EXPECT_THAT(*rit, 2);
@@ -23,7 +23,7 @@ TEST(RecursiveIteratorVecTest, PreIncrementAdvancesIterator) {
 
 TEST(RecursiveIteratorVecTest, PostIncrementReturnsCopyOfPrev) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
-  auto rit = recursive_iterator(vec);
+  auto rit = RecursiveIterator(vec);
   EXPECT_THAT(*rit, 1);
   EXPECT_THAT(*rit++, 1);
   EXPECT_THAT(*rit, 2);
@@ -31,7 +31,7 @@ TEST(RecursiveIteratorVecTest, PostIncrementReturnsCopyOfPrev) {
 
 TEST(RecursiveIteratorVecTest, IterDistanceIsSumOfInnerContainerSizes) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
-  auto rit = recursive_iterator(vec);
+  auto rit = RecursiveIterator(vec);
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 5);
 }
@@ -46,14 +46,14 @@ TEST(RecursiveIteratorVecTest, FlattensVectorDataLikeJoinIterator) {
 
 TEST(RecursiveIteratorVecTest, CanMutatePointedToData) {
   std::vector<std::vector<std::vector<int>>> vec{{{1, 2}}, {{3}, {4, 5}}};
-  auto rit = recursive_iterator(vec);
+  auto rit = RecursiveIterator(vec);
   *rit = 6;
   EXPECT_THAT(vec[0][0][0], 6);
 }
 
 TEST(BoundedRecursiveIteratorVecTest, PreIncrementAdvancesIterator) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
-  auto rit = recursive_iterator(vec, bounded<2>{});
+  auto rit = RecursiveIterator(vec, bounded<2>{});
   EXPECT_THAT(*rit, vec[0][0]);
   EXPECT_THAT(*++rit, vec[1][0]);
   EXPECT_THAT(*rit, vec[1][0]);
@@ -61,7 +61,7 @@ TEST(BoundedRecursiveIteratorVecTest, PreIncrementAdvancesIterator) {
 
 TEST(BoundedRecursiveIteratorVecTest, PostIncrementReturnsCopyOfPrev) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
-  auto rit = recursive_iterator(vec, bounded<2>{});
+  auto rit = RecursiveIterator(vec, bounded<2>{});
   EXPECT_THAT(*rit, vec[0][0]);
   EXPECT_THAT(*rit++, vec[0][0]);
   EXPECT_THAT(*rit, vec[1][0]);
@@ -69,7 +69,7 @@ TEST(BoundedRecursiveIteratorVecTest, PostIncrementReturnsCopyOfPrev) {
 
 TEST(BoundedRecursiveIteratorVecTest, IterDistanceSumOnNLayersSize) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
-  auto rit = recursive_iterator(vec, bounded<2>{});
+  auto rit = RecursiveIterator(vec, bounded<2>{});
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 3);
 }
@@ -84,7 +84,7 @@ TEST(BoundedRecursiveIteratorVecTest, ElementsAreUnwrappedAsATuple) {
 
 TEST(BoundedRecursiveIteratorVecTest, CanMutatePointedToData) {
   std::vector<std::vector<std::vector<int>>> vec{{{1, 2}}, {{3}, {4, 5}}};
-  auto rit = recursive_iterator(vec, bounded<2>{});
+  auto rit = RecursiveIterator(vec, bounded<2>{});
   rit->clear();
   EXPECT_THAT(vec[0][0], IsEmpty());
 }

test/unkeyed_iterator_test.cxx

@@ -7,29 +7,29 @@
 
 #include "iterator/end_aware_iterator.h"
 
-using iterator::end_aware_iterator;
-using iterator::unkeyed_iterator;
+using iterator::EndAwareIterator;
+using iterator::ValuesIterator;
 
 using testing::Ne;
 
 TEST(UnkeyedIteratorTest, IteratorOnlyReturnsValues) {
   std::map<int, int> map{{1, 2}, {2, 3}};
   std::vector<int> const expected{2, 3};
-  std::vector<int> const result{unkeyed_iterator{map.begin()},
-                                unkeyed_iterator{map.end()}};
+  std::vector<int> const result{ValuesIterator{map.begin()},
+                                ValuesIterator{map.end()}};
   EXPECT_THAT(result, expected);
 }
 
 TEST(UnkeyedIteratorTest, CanModifyIteratedCollectionValues) {
   std::map<int, int> map{{1, 2}, {2, 3}};
-  unkeyed_iterator uit{map.begin()};
+  ValuesIterator uit{map.begin()};
   *uit = 4;
   EXPECT_THAT(map[1], 4);
 }
 
 TEST(UnkeyedIteratorTest, PreIncrementAdvancesIterator) {
   std::map<int, int> map{{1, 2}, {2, 3}};
-  unkeyed_iterator it(map.begin());
+  ValuesIterator it(map.begin());
   EXPECT_THAT(*it, 2);
   EXPECT_THAT(*++it, 3);
   EXPECT_THAT(*it, 3);
@@ -37,7 +37,7 @@ TEST(UnkeyedIteratorTest, PreIncrementAdvancesIterator) {
 
 TEST(UnkeyedIteratorTest, PostIncrementReturnsCopyOfPrev) {
   std::map<int, int> map{{1, 2}, {2, 3}};
-  unkeyed_iterator it(map.begin());
+  ValuesIterator it(map.begin());
   EXPECT_THAT(*it, 2);
   EXPECT_THAT(*it++, 2);
   EXPECT_THAT(*it, 3);
@@ -45,7 +45,7 @@ TEST(UnkeyedIteratorTest, PostIncrementReturnsCopyOfPrev) {
 
 TEST(UnkeyedIteratorTest, PreDecrementAdvancesIterator) {
   std::map<int, int> map{{1, 2}, {2, 3}};
-  unkeyed_iterator it(++map.begin());
+  ValuesIterator it(++map.begin());
   EXPECT_THAT(*it, 3);
   EXPECT_THAT(*--it, 2);
   EXPECT_THAT(*it, 2);
@@ -53,7 +53,7 @@ TEST(UnkeyedIteratorTest, PreDecrementAdvancesIterator) {
 
 TEST(UnkeyedIteratorTest, PostDecrementReturnsCopyOfPrev) {
   std::map<int, int> map{{1, 2}, {2, 3}};
-  unkeyed_iterator it(++map.begin());
+  ValuesIterator it(++map.begin());
   EXPECT_THAT(*it, 3);
   EXPECT_THAT(*it--, 3);
   EXPECT_THAT(*it, 2);
@@ -61,19 +61,17 @@ TEST(UnkeyedIteratorTest, PostDecrementReturnsCopyOfPrev) {
 
 TEST(UnkeyedIteratorTest, EqualityIsPassthrough) {
   std::map<int, int> map{{1, 2}, {2, 3}};
-  EXPECT_THAT(++unkeyed_iterator(map.begin()), unkeyed_iterator(++map.begin()));
-  EXPECT_THAT(unkeyed_iterator(map.begin()),
-              Ne(unkeyed_iterator(++map.begin())));
+  EXPECT_THAT(++ValuesIterator(map.begin()), ValuesIterator(++map.begin()));
+  EXPECT_THAT(ValuesIterator(map.begin()), Ne(ValuesIterator(++map.begin())));
 }
 
 TEST(UnkeyedIteratorTest, PropagatesAtEnd) {
   std::map<int, int> map{{1, 2}, {2, 3}};
-  unkeyed_iterator end(end_aware_iterator(map.end(), map.end()));
+  ValuesIterator end(EndAwareIterator(map.end(), map.end()));
   EXPECT_EQ(end, iterator::sentinel);
 }
 
 TEST(UnkeyedIteratorTest, CanPointToObject) {
   std::map<int, int> map{{1, 2}, {2, 3}};
-  EXPECT_THAT(unkeyed_iterator(map.begin()).operator->(),
-              &(map.begin()->second));
+  EXPECT_THAT(ValuesIterator(map.begin()).operator->(), &(map.begin()->second));
 }

test/zip_iterator_test.cxx

@@ -14,7 +14,7 @@
 
 #include "xcode_gtest_helper.h"
 
-using iterator::zip_iterator;
+using iterator::ZipIterator;
 
 using testing::Eq;
 using testing::Ge;
@@ -30,22 +30,22 @@ TEST(ZipIteratorTest, CategoryIsMostRestrictiveOfTypes) {
   std::list<int> bid{1, 2, 3};
   std::forward_list<int> fwd{1, 2, 3};
   {
-    zip_iterator zit(rnd.begin(), ss.begin());
+    ZipIterator zit(rnd.begin(), ss.begin());
     StaticAssertTypeEq<std::iterator_traits<decltype(zit)>::iterator_category,
                        std::random_access_iterator_tag>();
   }
   {
-    zip_iterator zit(rnd.begin(), bid.begin());
+    ZipIterator zit(rnd.begin(), bid.begin());
     StaticAssertTypeEq<std::iterator_traits<decltype(zit)>::iterator_category,
                        std::bidirectional_iterator_tag>();
   }
   {
-    zip_iterator zit(rnd.begin(), fwd.begin());
+    ZipIterator zit(rnd.begin(), fwd.begin());
     StaticAssertTypeEq<std::iterator_traits<decltype(zit)>::iterator_category,
                        std::forward_iterator_tag>();
   }
   {
-    zip_iterator zit(bid.begin(), fwd.begin());
+    ZipIterator zit(bid.begin(), fwd.begin());
     StaticAssertTypeEq<std::iterator_traits<decltype(zit)>::iterator_category,
                        std::forward_iterator_tag>();
   }
@@ -54,7 +54,7 @@ TEST(ZipIteratorTest, CategoryIsMostRestrictiveOfTypes) {
 TEST(ZipIteratorTest, CanCombineParallelObjects) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
-  zip_iterator zit(is.begin(), ss.begin());
+  ZipIterator zit(is.begin(), ss.begin());
   EXPECT_THAT(std::get<0>(*zit), 1);
   EXPECT_THAT(std::get<1>(*zit), "A");
 }
@@ -62,7 +62,7 @@ TEST(ZipIteratorTest, CanCombineParallelObjects) {
 TEST(ZipIteratorTest, AdvancingMovesAllElements) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
-  zip_iterator zit(is.begin(), ss.begin());
+  ZipIterator zit(is.begin(), ss.begin());
   zit++;
   EXPECT_THAT(std::get<0>(*zit), 2);
   EXPECT_THAT(std::get<1>(*zit), "B");
@@ -71,7 +71,7 @@ TEST(ZipIteratorTest, AdvancingMovesAllElements) {
 TEST(ZipIteratorTest, CanDecrement) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
-  zip_iterator zit(is.begin(), ss.begin());
+  ZipIterator zit(is.begin(), ss.begin());
   ++zit;
   zit--;
   EXPECT_THAT(std::get<0>(*zit), 1);
@@ -81,7 +81,7 @@ TEST(ZipIteratorTest, CanDecrement) {
 TEST(ZipIteratorTest, CanMoveByAnyAmount) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
-  zip_iterator zit(is.begin(), ss.begin());
+  ZipIterator zit(is.begin(), ss.begin());
   zit = 2 + zit;
   EXPECT_THAT(std::get<0>(*zit), 3);
   EXPECT_THAT(std::get<1>(*zit), "C");
@@ -93,15 +93,15 @@ TEST(ZipIteratorTest, CanMoveByAnyAmount) {
 TEST(ZipIteratorTest, CanMarkDistance) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
-  zip_iterator zit(is.begin(), ss.begin());
-  zip_iterator zend(is.end(), ss.end());
+  ZipIterator zit(is.begin(), ss.begin());
+  ZipIterator zend(is.end(), ss.end());
   EXPECT_THAT(zend - zit, 3);
 }
 
 TEST(ZipIteratorTest, CanRandomAccess) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
-  zip_iterator zit(is.begin(), ss.begin());
+  ZipIterator zit(is.begin(), ss.begin());
   EXPECT_THAT(std::get<0>(zit[1]), 2);
   EXPECT_THAT(std::get<1>(zit[1]), "B");
 }
@@ -109,9 +109,9 @@ TEST(ZipIteratorTest, CanRandomAccess) {
 TEST(ZipIteratorTest, CanCompareIterators) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
-  zip_iterator const zit(is.begin(), ss.begin());
-  zip_iterator const zend(is.end(), ss.end());
-  EXPECT_THAT(zit, Eq(zip_iterator(is.begin(), ss.begin())));
+  ZipIterator const zit(is.begin(), ss.begin());
+  ZipIterator const zend(is.end(), ss.end());
+  EXPECT_THAT(zit, Eq(ZipIterator(is.begin(), ss.begin())));
   EXPECT_THAT(zit, Ne(zend));
   EXPECT_THAT(zit, Lt(zend));
   EXPECT_THAT(zit, Le(zend));