Cleaning up typedefs/traits.

streams/join.hpp

@@ -15,11 +15,14 @@ namespace stream { namespace detail {
   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(::stream::iterator<C>&& f, ::stream::iterator<C>&& l)
-      : start_(std::forward<::stream::iterator<C>>(f))
-      , finish_(std::forward<::stream::iterator<C>>(l))
-      {
+      iterator(impl_t && f, impl_t && l)
+      : start_(std::move(f)), finish_(std::move(l)) {
         if (start_ != finish_) {
           mem_ = *(start_);
           curr_ = mem_.begin();
@@ -28,13 +31,8 @@ namespace stream { namespace detail {
         }
       }
       
-      iterator(iterator const & other) {
-        JOIN_CTOR( )
-      }
-      
-      iterator(iterator && other) {
-        JOIN_CTOR( std::move )
-      }
+      iterator(iterator const & other) { JOIN_CTOR( ) }
+      iterator(iterator && other) { JOIN_CTOR( std::move ) }
       
       iterator & operator=(iterator const & other) {
         JOIN_CTOR( )
@@ -46,7 +44,7 @@ namespace stream { namespace detail {
         return *this;
       }
       
-      typename C::value_type operator*() { return *curr_; }
+      reference operator*() { return *curr_; }
       
       iterator& operator++() {
         ++curr_;
@@ -64,9 +62,9 @@ namespace stream { namespace detail {
           end_ = mem_.end();
         }
       }
-      ::stream::iterator<C> start_, finish_;
+      impl_t start_, finish_;
       C mem_;
-      typename C::const_iterator curr_, end_;
+      local_iterator curr_, end_;
     };
   }
   
@@ -87,20 +85,19 @@ namespace stream { namespace detail {
   };
   
   template <typename C>
-  auto make_join(stream_base<C> const& sb) -> stream_base<typename C::value_type>  {
-    using T = typename C::value_type;
+  stream_base<typename C::value_type> make_join(stream_base<C> const& sb) {
     return std::make_shared<join_stream<C>>(sb);
   }
   
   template <typename T>
   template <typename F>
-  auto stream_base<T>::flatmap(F&& func) && -> stream_base<flatmap_f<F>>  {
+  stream_base<traits::fmapped_t<T, F>> stream_base<T>::flatmap(F&& func) && {
     return make_join(std::move(*this).map(func));
   }
   
   template <typename T>
   template <typename F>
-  auto stream_base<T>::flatmap(F&& func) const & -> stream_base<flatmap_f<F>>  {
+  stream_base<traits::fmapped_t<T, F>> stream_base<T>::flatmap(F&& func) const & {
     return make_join(map(func));
   }
 } }

streams/map.hpp

@@ -36,13 +36,13 @@ namespace stream { namespace detail {
   
   template <typename T>
   template <typename F>
-  auto stream_base<T>::map(F&& func) && -> stream_base<map_f<F>> {
-    return std::make_shared<map_stream<T, map_f<F>>>(func, std::move(*this));
+  stream_base<traits::mapped_t<T, F>> stream_base<T>::map(F&& func) && {
+    return std::make_shared<map_stream<T, traits::mapped_t<T, F>>>(func, std::move(*this));
   }
   
   template <typename T>
   template <typename F>
-  auto stream_base<T>::map(F&& func) const & -> stream_base<map_f<F>> {
-    return std::make_shared<map_stream<T, map_f<F>>>(func, *this);
+  stream_base<traits::mapped_t<T, F>> stream_base<T>::map(F&& func) const & {
+    return std::make_shared<map_stream<T, traits::mapped_t<T, F>>>(func, *this);
   }
 } }

streams/streams.hpp

@@ -101,40 +101,25 @@ namespace stream {
     class stream_base_pointer_impl {};
     
     template <typename T>
-    class stream_base_pointer_impl<T, typename std::enable_if<detail::is_dereferencable<typename std::remove_reference<T>::type>::value>::type> {
+    class stream_base_pointer_impl<T, typename std::enable_if<traits::is_dereferencable<T>::value>::type> {
     private:
-      using self = stream_base<T>;
-      using noref = typename std::remove_reference<T>::type;
-      using element_type = typename std::pointer_traits<noref>::element_type;
+      using self_t = stream_base<T>;
+      using pointer = typename std::remove_reference<T>::type;
+      using element_type = typename std::pointer_traits<pointer>::element_type;
     public:
       auto deref() const & -> stream_base<element_type &> {
-        return static_cast<stream_base<T> const *>(this)->map([](T const & p) -> element_type & { return *p; });
+        return static_cast<self_t const *>(this)->map([](T const & p) -> element_type & { return *p; });
       }
       
       auto deref() && -> stream_base<element_type &> {
-        return static_cast<stream_base<T> &&>(*this).map([](T const & p) -> element_type & { return *p; });
+        return static_cast<self_t &&>(*this).map([](T const & p) -> element_type & { return *p; });
       }
     };
     
     template <typename T>
     class stream_base : public stream_base_pointer_impl<T> {
     private:
-      template <typename F>
-      using map_f = decltype(std::declval<F>()(std::declval<T>()));
-      template <typename F>
-      using flatmap_f = typename decltype(std::declval<F>()(std::declval<T>()))::value_type;
-      template <typename F>
-      using memvar_f = typename map_member_object<F>::type;
-      template <typename F>
-      using memfun_f = typename map_member_function<F>::type;
-      template <typename F>
-      using is_memvar = std::is_member_object_pointer<F>;
-      template <typename F>
-      using is_memfun = std::is_member_function_pointer<F>;
-
-      using self = stream_base<T>;
-      using noref = typename std::remove_reference<T>::type;
-      using clean = typename std::decay<T>::type;
+      using value_type = typename std::decay<T>::type;
     public:
       template <typename Stream>
       stream_base(std::shared_ptr<Stream> && impl) {
@@ -148,24 +133,24 @@ namespace stream {
       
       bool empty() const { return begin() == end(); }
       
-      std::vector<clean> collect() const {
-        std::vector<clean> coll;
+      std::vector<value_type> collect() const {
+        std::vector<value_type> coll;
         collect(coll);
         return coll;
       }
       
       template <typename C, typename = typename std::enable_if<!std::is_void<typename C::value_type>::value, void>::type>
-      C& collect(C & coll) const {
+      C & collect(C & coll) const {
         std::copy(begin(), end(), std::inserter(coll, coll.end()));
         return coll;
       }
       
       template <typename F>
-      clean accumulate(F&& fold, clean const& accum) const {
+      value_type accumulate(F&& fold, value_type const& accum) const {
         return std::accumulate(begin(), end(), accum, fold);
       }
       
-      clean accumulate(clean const& accum) const {
+      value_type accumulate(value_type const& accum) const {
         return std::accumulate(begin(), end(), accum);
       }
       
@@ -175,46 +160,46 @@ namespace stream {
       }
       
       template <typename F>
-      stream_base<map_f<F>> map(F&& func) const &;
+      stream_base<traits::mapped_t<T, F>> map(F&& func) const &;
       template <typename F>
       stream_base<T> filter(F&& func) const &;
       template <typename F>
-      stream_base<flatmap_f<F>> flatmap(F&& func) const &;
+      stream_base<traits::fmapped_t<T, F>> flatmap(F&& func) const &;
       
       template <typename F>
-      stream_base<map_f<F>> map(F&& func) &&;
+      stream_base<traits::mapped_t<T, F>> map(F&& func) &&;
       template <typename F>
       stream_base<T> filter(F&& func) &&;
       template <typename F>
-      stream_base<flatmap_f<F>> flatmap(F&& func) &&;
+      stream_base<traits::fmapped_t<T, F>> flatmap(F&& func) &&;
       
       template <typename Cast>
-      auto cast() const & -> stream_base<Cast const &> {
+      stream_base<Cast const &> cast() const & {
         return map([](T const & p) -> Cast const & { return p; });
       }
       
       template <typename Cast>
-      auto cast() && -> stream_base<Cast const &> {
+      stream_base<Cast const &> cast() && {
         return std::move(*this).map([](T const & p) -> Cast const & { return p; });
       }
       
-      template <typename F, typename = typename std::enable_if<is_memvar<F>::value>::type>
-      auto map(F && memvar) const & -> stream_base<memvar_f<F>> {
+      template <typename F, typename = traits::is_memvar_t<F>>
+      stream_base<traits::memvar_f<F>> map(F && memvar) const & {
         return map(map_member_object<F>{memvar});
       }
       
-      template <typename F, typename = typename std::enable_if<is_memfun<F>::value>::type>
-      auto map(F && memvar) const & -> stream_base<memfun_f<F>> {
+      template <typename F, typename = traits::is_memfun_t<F>>
+      stream_base<traits::memfun_f<F>> map(F && memvar) const & {
         return map(map_member_function<F>{memvar});
       }
 
-      template <typename F, typename = typename std::enable_if<is_memvar<F>::value>::type>
-      auto map(F && memvar) && -> stream_base<memvar_f<F>> {
+      template <typename F, typename = traits::is_memvar_t<F>>
+      stream_base<traits::memvar_f<F>> map(F && memvar) && {
         return std::move(*this).map(map_member_object<F>{memvar});
       }
 
-      template <typename F, typename = typename std::enable_if<is_memfun<F>::value>::type>
-      auto map(F && memvar) && -> stream_base<memfun_f<F>> {
+      template <typename F, typename = traits::is_memfun_t<F>>
+      stream_base<traits::memfun_f<F>> map(F && memvar) && {
         return std::move(*this).map(map_member_function<F>{memvar});
       }
     private:

streams/traits.hpp

@@ -21,9 +21,7 @@ namespace stream { namespace detail {
     operator T &() const { return *value; }
     T * value;
   };
-} }
 
-namespace stream { namespace detail {
   template <typename F> struct map_member_object;
   template <typename T, typename R>
   struct map_member_object<R T::*> {
@@ -39,9 +37,19 @@ namespace stream { namespace detail {
     type operator()(T const & val) const { return (val.*mem)(); }
     R (T::* mem)() const;
   };
-}}
+} }
+
+namespace stream { namespace traits {
+  template <typename F>
+  using memvar_f = typename detail::map_member_object<F>::type;
+  template <typename F>
+  using memfun_f = typename detail::map_member_function<F>::type;
+  
+  template <typename F>
+  using is_memvar_t = typename std::enable_if<std::is_member_object_pointer<F>::value>::type;
+  template <typename F>
+  using is_memfun_t = typename std::enable_if<std::is_member_function_pointer<F>::value>::type;
 
-namespace stream { namespace detail {
   template <typename T, typename = void>
   struct is_dereferencable : public std::false_type {};
 
@@ -50,4 +58,10 @@ namespace stream { namespace detail {
   
   template <typename T>
   struct is_dereferencable<T, typename std::enable_if<!std::is_void<decltype(*std::declval<T>())>::value>::type> : public std::true_type {};
-}}
+
+  template <typename T, typename F>
+  using mapped_t = decltype(std::declval<F>()(std::declval<T>()));
+  
+  template <typename T, typename F>
+  using fmapped_t = typename decltype(std::declval<F>()(std::declval<T>()))::value_type;
+} }