Eliminate delegate_iterator macros.

include/stream/streams/filter.hpp

@@ -1,37 +1,38 @@
 #pragma once
 
 namespace stream { namespace detail {
-  namespace filter {
-    template <typename T> class iterator {
-    public:
-      iterator(std::function<bool(T const &)> f, ::stream::iterator<T> && impl,
-               ::stream::iterator<T> && end)
-          : pred_(f), impl_(std::forward<::stream::iterator<T>>(impl)),
-            end_(std::forward<::stream::iterator<T>>(end)) {
-        advance();
-      }
+  template <typename T> class filter_iterator {
+  public:
+    filter_iterator(std::function<bool(T const &)> f, iterator<T> && impl,
+                    iterator<T> && end)
+        : pred_(f), impl_(std::forward<iterator<T>>(impl)),
+          end_(std::forward<iterator<T>>(end)) {
+      advance();
+    }
 
-      T operator*() { return mem_; }
+    T operator*() { return mem_; }
 
-      iterator & operator++() {
-        ++impl_;
-        advance();
-        return *this;
-      }
+    filter_iterator & operator++() {
+      ++impl_;
+      advance();
+      return *this;
+    }
 
-      DELEGATE_ITERATOR_IMPL_BASE(impl_)
-    private:
-      void advance() {
-        while (impl_ != end_ && !pred_(mem_ = *impl_)) {
-          ++impl_;
-        }
+    bool operator==(filter_iterator const & rhs) const {
+      return impl_ == rhs.impl_;
+    }
+    
+  private:
+    void advance() {
+      while (impl_ != end_ && !pred_(mem_ = *impl_)) {
+        ++impl_;
       }
+    }
 
-      std::function<bool(T const &)> pred_;
-      ref_or_val<T> mem_; // To avoid re-calcs, we store this
-      ::stream::iterator<T> impl_, end_;
-    };
-  }
+    std::function<bool(T const &)> pred_;
+    ref_or_val<T> mem_; // To avoid re-calcs, we store this
+    iterator<T> impl_, end_;
+  };
 
   template <typename T> class filter_stream {
   public:
@@ -40,11 +41,11 @@ namespace stream { namespace detail {
         : pred_(func), source_(sb) {}
 
     iterator<T> begin() {
-      return {filter::iterator<T>{pred_, source_.begin(), source_.end()}};
+      return {filter_iterator<T>{pred_, source_.begin(), source_.end()}};
     }
 
     iterator<T> end() {
-      return {filter::iterator<T>{pred_, source_.end(), source_.end()}};
+      return {filter_iterator<T>{pred_, source_.end(), source_.end()}};
     }
 
   private:

include/stream/streams/join.hpp

@@ -12,74 +12,74 @@ namespace stream { namespace detail {
   std::advance(curr_, n);                                                      \
   end_ = mem_.end();
 
-  namespace join {
-    template <typename C> class iterator {
-    private:
-      using impl_t = ::stream::iterator<C>;
-      using local_iterator = typename C::const_iterator;
-
-    public:
-      using reference = typename local_iterator::reference;
-
-    public:
-      iterator(impl_t && f, impl_t && l)
-          : start_(std::move(f)), finish_(std::move(l)) {
-        if (start_ != finish_) {
-          mem_ = *(start_);
-          curr_ = mem_.begin();
-          end_ = mem_.end();
-          advance();
-        }
+  template <typename C> class join_iterator {
+  public:
+    using reference = typename C::const_iterator::reference;
+
+  public:
+    join_iterator(iterator<C> && f, iterator<C> && l)
+        : start_(std::move(f)), finish_(std::move(l)) {
+      if (start_ != finish_) {
+        mem_ = *(start_);
+        curr_ = mem_.begin();
+        end_ = mem_.end();
+        advance();
       }
+    }
 
-      iterator(iterator const & other){JOIN_CTOR()} iterator(iterator && other){
-          JOIN_CTOR(std::move)}
+    join_iterator(join_iterator const & other) {
+      JOIN_CTOR()
+    }
+    
+    join_iterator(join_iterator && other){
+      JOIN_CTOR(std::move)
+    }
 
-      iterator &
-      operator=(iterator const & other) {
-        JOIN_CTOR()
-        return *this;
-      }
+    join_iterator & operator=(join_iterator const & other) {
+      JOIN_CTOR()
+      return *this;
+    }
 
-      iterator & operator=(iterator && other) {
-        JOIN_CTOR(std::move)
-        return *this;
-      }
+    join_iterator & operator=(join_iterator && other) {
+      JOIN_CTOR(std::move)
+      return *this;
+    }
 
-      reference operator*() { return *curr_; }
+    reference operator*() { return *curr_; }
 
-      iterator & operator++() {
-        ++curr_;
-        advance();
-        return *this;
-      }
+    join_iterator & operator++() {
+      ++curr_;
+      advance();
+      return *this;
+    }
 
-      DELEGATE_ITERATOR_IMPL_BASE(start_)
-    private:
-      void advance() {
-        while (curr_ == end_ && start_ != finish_) {
-          if (++start_ == finish_) { break; }
-          mem_ = *start_;
-          curr_ = mem_.begin();
-          end_ = mem_.end();
-        }
+    bool operator==(join_iterator const & rhs) const { return start_ == rhs.start_; }
+  private:
+    void advance() {
+      while (curr_ == end_ && start_ != finish_) {
+        if (++start_ == finish_) { break; }
+        mem_ = *start_;
+        curr_ = mem_.begin();
+        end_ = mem_.end();
       }
-      impl_t start_, finish_;
-      C mem_;
-      local_iterator curr_, end_;
-    };
-  }
+    }
+    iterator<C> start_;
+    iterator<C> finish_;
+    C mem_;
+    typename C::const_iterator curr_;
+    typename C::const_iterator end_;
+  };
 
   template <typename C> class join_stream {
   public:
     using T = typename C::value_type;
     explicit join_stream(stream_base<C> const & sb) : source_(sb) {}
 
-    ::stream::iterator<T> begin() {
-      return {join::iterator<C>{source_.begin(), source_.end()}};
+    iterator<T> begin() {
+      return {join_iterator<C>{source_.begin(), source_.end()}};
     }
-    ::stream::iterator<T> end() {
-      return {join::iterator<C>{source_.end(), source_.end()}};
+    iterator<T> end() {
+      return {join_iterator<C>{source_.end(), source_.end()}};
     }
 
   private:

include/stream/streams/make_stream.hpp

@@ -8,7 +8,7 @@ namespace stream {
    * will take ownership of cont. Otherwise, we capture cont by reference to maximise performance.
    */
   template <typename C>
-  detail::stream_base<detail::source::reference<C>> make_stream(C && cont) {
+  auto make_stream(C && cont) -> detail::stream_base<decltype(*cont.begin())> {
     return std::make_shared<detail::source_stream<C>>(std::forward<C>(cont));
   }
 

include/stream/streams/map.hpp

@@ -1,19 +1,21 @@
 #pragma once
 
 namespace stream { namespace detail {
-  namespace map {
-    template <typename T, typename R> class iterator {
-    public:
-      iterator(std::function<R(T const &)> f, ::stream::iterator<T> && impl)
-          : fun_(f), impl_(std::forward<::stream::iterator<T>>(impl)) {}
-
-      R operator*() { return fun_(*impl_); }
-      DELEGATE_ITERATOR_IMPL(impl_)
-    private:
-      std::function<R(T const &)> fun_;
-      ::stream::iterator<T> impl_;
-    };
-  }
+  template <typename T, typename R> class map_iterator {
+  public:
+    map_iterator(std::function<R(T const &)> f, iterator<T> && impl)
+        : fun_(f), impl_(std::forward<iterator<T>>(impl)) {}
+
+    R operator*() { return fun_(*impl_); }
+    map_iterator & operator++() {
+      ++impl_;
+      return *this;
+    }
+    bool operator==(map_iterator const & rhs) const { return impl_ == rhs.impl_; }
+  private:
+    std::function<R(T const &)> fun_;
+    iterator<T> impl_;
+  };
 
   template <typename T, typename R> class map_stream {
   public:
@@ -21,9 +23,9 @@ namespace stream { namespace detail {
     map_stream(F && func, stream_base<T> const & sb)
         : fun_(func), source_(sb) {}
 
-    iterator<R> begin() { return {map::iterator<T, R>{fun_, source_.begin()}}; }
+    iterator<R> begin() { return {map_iterator<T, R>{fun_, source_.begin()}}; }
 
-    iterator<R> end() { return {map::iterator<T, R>{fun_, source_.end()}}; }
+    iterator<R> end() { return {map_iterator<T, R>{fun_, source_.end()}}; }
 
   private:
     std::function<R(T const &)> fun_;

include/stream/streams/source.hpp

@@ -1,34 +1,36 @@
 #pragma once
 
 namespace stream { namespace detail {
-  namespace source {
-    template <typename Iter> class iterator {
-    public:
-      using value_type = typename std::iterator_traits<Iter>::reference;
-      explicit iterator(Iter it) : impl_(it) {}
-
-      value_type operator*() { return *impl_; }
-      DELEGATE_ITERATOR_IMPL(impl_)
-    private:
-      Iter impl_;
-    };
-
-    template <typename C>
-    using reference = decltype(*std::declval<C>().begin());
-  }
+  template <typename Iter> class source_iterator {
+  public:
+    using value_type = typename std::iterator_traits<Iter>::reference;
+    explicit source_iterator(Iter it) : impl_(it) {}
+
+    value_type operator*() { return *impl_; }
+    source_iterator & operator++() {
+      ++impl_;
+      return *this;
+    }
+    bool operator==(source_iterator const & rhs) const {
+      return impl_ == rhs.impl_;
+    }
+    
+  private:
+    Iter impl_;
+  };
 
   template <typename C> class source_stream {
   public:
-    typedef source::reference<C> reference;
     typedef decltype(std::declval<C>().begin()) _iterator;
+    typedef decltype(*std::declval<_iterator>()) reference;
 
     explicit source_stream(C && cont) : source_(std::forward<C>(cont)) {}
 
     iterator<reference> begin() {
-      return {source::iterator<_iterator>{source_.begin()}};
+      return {source_iterator<_iterator>{source_.begin()}};
     }
     iterator<reference> end() {
-      return {source::iterator<_iterator>{source_.end()}};
+      return {source_iterator<_iterator>{source_.end()}};
     }
 
   private:
@@ -42,8 +44,8 @@ namespace stream { namespace detail {
 
     explicit range_stream(It b, It e) : begin_(b), end_(e) {}
 
-    iterator<reference> begin() { return {source::iterator<It>{begin_}}; }
-    iterator<reference> end() { return {source::iterator<It>{end_}}; }
+    iterator<reference> begin() { return {source_iterator<It>{begin_}}; }
+    iterator<reference> end() { return {source_iterator<It>{end_}}; }
 
   private:
     It begin_, end_;

include/stream/streams/streams.hpp

@@ -5,16 +5,6 @@
 #include <numeric>
 #include <vector>
 
-#define DELEGATE_ITERATOR_IMPL_BASE(impl)                                      \
-  bool operator==(iterator const & other) const { return impl == other.impl; }
-
-#define DELEGATE_ITERATOR_IMPL(impl)                                           \
-  DELEGATE_ITERATOR_IMPL_BASE(impl)                                            \
-  iterator & operator++() {                                                    \
-    ++impl;                                                                    \
-    return *this;                                                              \
-  }
-
 namespace stream {
 #define STREAM_ITERATOR_COPY()                                                 \
   copy(other.copy), dereference(other.dereference), compare(other.compare),    \