diff --git a/hpx/parallel/segmented_algorithms/detail/dispatch.hpp b/hpx/parallel/segmented_algorithms/detail/dispatch.hpp
index bd997e81d2e5..39432d91d0b3 100644
--- a/hpx/parallel/segmented_algorithms/detail/dispatch.hpp
+++ b/hpx/parallel/segmented_algorithms/detail/dispatch.hpp
@@ -90,7 +90,7 @@ namespace hpx { namespace parallel { HPX_INLINE_NAMESPACE(v1) { namespace detail
             return
                 detail::algorithm_result_helper<R>::call(
                     algo.call(policy, boost::mpl::true_(),
-                            segmented_local_iterator_traits<Args>::local(args)...
+                        segmented_local_iterator_traits<Args>::local(args)...
                     )
                 );
         }
diff --git a/hpx/parallel/traits/projected.hpp b/hpx/parallel/traits/projected.hpp
index 50aa42b5a83f..20cbeddfeb78 100644
--- a/hpx/parallel/traits/projected.hpp
+++ b/hpx/parallel/traits/projected.hpp
@@ -7,6 +7,7 @@
 #define HPX_PARALLEL_TRAITS_PROJECTED_JUL_18_2015_1001PM
 
 #include <hpx/config.hpp>
+#include <hpx/traits/segmented_iterator_traits.hpp>
 #include <hpx/util/result_of.hpp>
 #include <hpx/util/decay.hpp>
 #include <hpx/util/detail/pack.hpp>
@@ -14,6 +15,25 @@
 #include <type_traits>
 #include <iterator>
 
+///////////////////////////////////////////////////////////////////////////////
+namespace hpx { namespace traits
+{
+    // For segmented iterators, we consider the local_raw_iterator instead of
+    // the given one.
+    template <typename Iterator>
+    struct projected_iterator<Iterator,
+        typename std::enable_if<is_segmented_iterator<Iterator>::value>::type>
+    {
+        typedef typename segmented_iterator_traits<
+                Iterator
+            >::local_iterator local_iterator;
+
+        typedef typename segmented_local_iterator_traits<
+                local_iterator
+            >::local_raw_iterator type;
+    };
+}}
+
 namespace hpx { namespace parallel { namespace traits
 {
     ///////////////////////////////////////////////////////////////////////////
@@ -99,7 +119,7 @@ namespace hpx { namespace parallel { namespace traits
     struct is_projected
       : detail::is_projected<
             typename hpx::util::decay<F>::type,
-            typename hpx::util::decay<Iter>::type>
+            typename hpx::traits::projected_iterator<Iter>::type>
     {};
 
     ///////////////////////////////////////////////////////////////////////////
@@ -107,7 +127,8 @@ namespace hpx { namespace parallel { namespace traits
     struct projected
     {
         typedef typename hpx::util::decay<Proj>::type projector_type;
-        typedef typename hpx::util::decay<Iter>::type iterator_type;
+        typedef typename hpx::traits::projected_iterator<Iter>::type
+            iterator_type;
     };
 
     template <typename Projected, typename Enable = void>
diff --git a/hpx/traits.hpp b/hpx/traits.hpp
index 2d3ced90b86e..c8fae4eb7a4f 100644
--- a/hpx/traits.hpp
+++ b/hpx/traits.hpp
@@ -152,9 +152,15 @@ namespace hpx { namespace traits
     template <typename Iterator, typename Enable = void>
     struct segmented_iterator_traits;
 
+    template <typename Iterator, typename Enable = void>
+    struct is_segmented_iterator;
+
     template <typename Iterator, typename Enable = void>
     struct segmented_local_iterator_traits;
 
+    template <typename T, typename Enable = void>
+    struct projected_iterator;
+
     ///////////////////////////////////////////////////////////////////////////
     template <typename T, typename Enable = void>
     struct is_distribution_policy;
diff --git a/hpx/traits/segmented_iterator_traits.hpp b/hpx/traits/segmented_iterator_traits.hpp
index fb120706f10c..75cc2bda41b8 100644
--- a/hpx/traits/segmented_iterator_traits.hpp
+++ b/hpx/traits/segmented_iterator_traits.hpp
@@ -18,6 +18,11 @@ namespace hpx { namespace traits
         typedef std::false_type is_segmented_iterator;
     };
 
+    template <typename Iterator, typename Enable>
+    struct is_segmented_iterator
+      : segmented_iterator_traits<Iterator>::is_segmented_iterator
+    {};
+
     ///////////////////////////////////////////////////////////////////////////
     // traits allowing to distinguish iterators which have a purely local
     // representation
@@ -52,170 +57,11 @@ namespace hpx { namespace traits
     };
 
     ///////////////////////////////////////////////////////////////////////////
-    namespace functional
+    template <typename T, typename Enable>
+    struct projected_iterator
     {
-        struct segmented_iterator_segment
-        {
-            template <typename Iterator>
-            struct apply
-            {
-                typedef typename segmented_iterator_traits<
-                        Iterator
-                    >::segment_iterator type;
-
-                template <typename T>
-                struct result;
-
-                template <typename This, typename Iter>
-                struct result<This(Iter)>
-                {
-                    typedef typename apply::type type;
-                };
-
-                template <typename Iter>
-                typename result<segmented_iterator_segment(Iter)>::type
-                operator()(Iter iter) const
-                {
-                    return segmented_iterator_traits<Iterator>::segment(iter);
-                };
-            };
-        };
-
-        struct segmented_iterator_local
-        {
-            template <typename Iterator>
-            struct apply
-            {
-                typedef typename segmented_iterator_traits<
-                        Iterator
-                    >::local_iterator type;
-
-                template <typename T>
-                struct result;
-
-                template <typename This, typename Iter>
-                struct result<This(Iter)>
-                {
-                    typedef typename apply::type type;
-                };
-
-                template <typename Iter>
-                typename result<segmented_iterator_local(Iter)>::type
-                operator()(Iter iter) const
-                {
-                    return segmented_iterator_traits<Iterator>::local(iter);
-                };
-            };
-        };
-
-        struct segmented_iterator_begin
-        {
-            template <typename Iterator>
-            struct apply
-            {
-                typedef typename segmented_iterator_traits<
-                        Iterator
-                    >::local_iterator type;
-
-                template <typename T>
-                struct result;
-
-                template <typename This, typename SegIter>
-                struct result<This(SegIter)>
-                {
-                    typedef typename apply::type type;
-                };
-
-                template <typename SegIter>
-                typename result<segmented_iterator_begin(SegIter)>::type
-                operator()(SegIter iter) const
-                {
-                    return segmented_iterator_traits<Iterator>::begin(iter);
-                };
-            };
-        };
-
-        struct segmented_iterator_end
-        {
-            template <typename Iterator>
-            struct apply
-            {
-                typedef typename segmented_iterator_traits<
-                        Iterator
-                    >::local_iterator type;
-
-                template <typename T>
-                struct result;
-
-                template <typename This, typename SegIter>
-                struct result<This(SegIter)>
-                {
-                    typedef typename apply::type type;
-                };
-
-                template <typename SegIter>
-                typename result<segmented_iterator_end(SegIter)>::type
-                operator()(SegIter iter) const
-                {
-                    return segmented_iterator_traits<Iterator>::end(iter);
-                };
-            };
-        };
-
-        struct segmented_iterator_local_begin
-        {
-            template <typename Iterator>
-            struct apply
-            {
-                typedef typename segmented_iterator_traits<
-                        Iterator
-                    >::local_raw_iterator type;
-
-                template <typename T>
-                struct result;
-
-                template <typename This, typename LocalSegIter>
-                struct result<This(LocalSegIter)>
-                {
-                    typedef typename apply::type type;
-                };
-
-                template <typename LocalSegIter>
-                typename result<segmented_iterator_local_begin(LocalSegIter)>::type
-                operator()(LocalSegIter iter) const
-                {
-                    return segmented_iterator_traits<Iterator>::begin(iter);
-                };
-            };
-        };
-
-        struct segmented_iterator_local_end
-        {
-            template <typename Iterator>
-            struct apply
-            {
-                typedef typename segmented_iterator_traits<
-                        Iterator
-                    >::local_raw_iterator type;
-
-                template <typename T>
-                struct result;
-
-                template <typename This, typename LocalSegIter>
-                struct result<This(LocalSegIter)>
-                {
-                    typedef typename apply::type type;
-                };
-
-                template <typename LocalSegIter>
-                typename result<segmented_iterator_local_end(LocalSegIter)>::type
-                operator()(LocalSegIter iter) const
-                {
-                    return segmented_iterator_traits<Iterator>::end(iter);
-                };
-            };
-        };
-    }
+        typedef typename hpx::util::decay<T>::type type;
+    };
 }}
 
 #endif
diff --git a/hpx/util/functional/segmented_iterator_helpers.hpp b/hpx/util/functional/segmented_iterator_helpers.hpp
new file mode 100644
index 000000000000..ca61af0016e6
--- /dev/null
+++ b/hpx/util/functional/segmented_iterator_helpers.hpp
@@ -0,0 +1,179 @@
+//  Copyright (c) 2015 Hartmut Kaiser
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(HPX_UTIL_FUNCTIONAL_SEGMENTED_ITERATOR_HELPERS_JUL_20_2015_1105AM)
+#define HPX_UTIL_FUNCTIONAL_SEGMENTED_ITERATOR_HELPERS_JUL_20_2015_1105AM
+
+#include <hpx/traits.hpp>
+#include <hpx/traits/segmented_iterator_traits.hpp>
+
+namespace hpx { namespace util { namespace functional
+{
+    ///////////////////////////////////////////////////////////////////////////
+    struct segmented_iterator_segment
+    {
+        template <typename Iterator>
+        struct apply
+        {
+            typedef typename traits::segmented_iterator_traits<
+                    Iterator
+                >::segment_iterator type;
+
+            template <typename T>
+            struct result;
+
+            template <typename This, typename Iter>
+            struct result<This(Iter)>
+            {
+                typedef typename apply::type type;
+            };
+
+            template <typename Iter>
+            typename result<segmented_iterator_segment(Iter)>::type
+            operator()(Iter iter) const
+            {
+                return traits::segmented_iterator_traits<Iterator>::segment(iter);
+            };
+        };
+    };
+
+    struct segmented_iterator_local
+    {
+        template <typename Iterator>
+        struct apply
+        {
+            typedef typename traits::segmented_iterator_traits<
+                    Iterator
+                >::local_iterator type;
+
+            template <typename T>
+            struct result;
+
+            template <typename This, typename Iter>
+            struct result<This(Iter)>
+            {
+                typedef typename apply::type type;
+            };
+
+            template <typename Iter>
+            typename result<segmented_iterator_local(Iter)>::type
+            operator()(Iter iter) const
+            {
+                return traits::segmented_iterator_traits<Iterator>::local(iter);
+            };
+        };
+    };
+
+    struct segmented_iterator_begin
+    {
+        template <typename Iterator>
+        struct apply
+        {
+            typedef typename traits::segmented_iterator_traits<
+                    Iterator
+                >::local_iterator type;
+
+            template <typename T>
+            struct result;
+
+            template <typename This, typename SegIter>
+            struct result<This(SegIter)>
+            {
+                typedef typename apply::type type;
+            };
+
+            template <typename SegIter>
+            typename result<segmented_iterator_begin(SegIter)>::type
+            operator()(SegIter iter) const
+            {
+                return traits::segmented_iterator_traits<Iterator>::begin(iter);
+            };
+        };
+    };
+
+    struct segmented_iterator_end
+    {
+        template <typename Iterator>
+        struct apply
+        {
+            typedef typename traits::segmented_iterator_traits<
+                    Iterator
+                >::local_iterator type;
+
+            template <typename T>
+            struct result;
+
+            template <typename This, typename SegIter>
+            struct result<This(SegIter)>
+            {
+                typedef typename apply::type type;
+            };
+
+            template <typename SegIter>
+            typename result<segmented_iterator_end(SegIter)>::type
+            operator()(SegIter iter) const
+            {
+                return traits::segmented_iterator_traits<Iterator>::end(iter);
+            };
+        };
+    };
+
+    struct segmented_iterator_local_begin
+    {
+        template <typename Iterator>
+        struct apply
+        {
+            typedef typename traits::segmented_iterator_traits<
+                    Iterator
+                >::local_raw_iterator type;
+
+            template <typename T>
+            struct result;
+
+            template <typename This, typename LocalSegIter>
+            struct result<This(LocalSegIter)>
+            {
+                typedef typename apply::type type;
+            };
+
+            template <typename LocalSegIter>
+            typename result<segmented_iterator_local_begin(LocalSegIter)>::type
+            operator()(LocalSegIter iter) const
+            {
+                return traits::segmented_iterator_traits<Iterator>::begin(iter);
+            };
+        };
+    };
+
+    struct segmented_iterator_local_end
+    {
+        template <typename Iterator>
+        struct apply
+        {
+            typedef typename traits::segmented_iterator_traits<
+                    Iterator
+                >::local_raw_iterator type;
+
+            template <typename T>
+            struct result;
+
+            template <typename This, typename LocalSegIter>
+            struct result<This(LocalSegIter)>
+            {
+                typedef typename apply::type type;
+            };
+
+            template <typename LocalSegIter>
+            typename result<segmented_iterator_local_end(LocalSegIter)>::type
+            operator()(LocalSegIter iter) const
+            {
+                return traits::segmented_iterator_traits<Iterator>::end(iter);
+            };
+        };
+    };
+}}}
+
+#endif
+
diff --git a/hpx/util/zip_iterator.hpp b/hpx/util/zip_iterator.hpp
index bcb26fe7fa97..69278a130ddc 100644
--- a/hpx/util/zip_iterator.hpp
+++ b/hpx/util/zip_iterator.hpp
@@ -8,10 +8,11 @@
 #define HPX_UTIL_ZIP_ITERATOR_MAY_29_2014_0852PM
 
 #include <hpx/util/tuple.hpp>
+#include <hpx/traits/segmented_iterator_traits.hpp>
 #include <hpx/util/detail/pack.hpp>
 #include <hpx/util/result_of.hpp>
+#include <hpx/util/functional/segmented_iterator_helpers.hpp>
 #include <hpx/runtime/serialization/serialize_sequence.hpp>
-#include <hpx/traits/segmented_iterator_traits.hpp>
 
 #include <boost/fusion/algorithm/iteration/for_each.hpp>
 #include <boost/iterator/iterator_facade.hpp>
@@ -528,7 +529,7 @@ namespace hpx { namespace traits
         {
             return segment_iterator(
                 functional::lift_zipped_iterators<
-                        functional::segmented_iterator_segment, iterator
+                        util::functional::segmented_iterator_segment, iterator
                     >::call(iter));
         }
 
@@ -538,7 +539,7 @@ namespace hpx { namespace traits
         {
             return local_iterator(
                 functional::lift_zipped_iterators<
-                        functional::segmented_iterator_local, iterator
+                        util::functional::segmented_iterator_local, iterator
                     >::call(iter));
         }
 
@@ -548,7 +549,7 @@ namespace hpx { namespace traits
         {
             return local_iterator(
                 functional::lift_zipped_iterators<
-                        functional::segmented_iterator_begin, iterator
+                        util::functional::segmented_iterator_begin, iterator
                     >::call(iter));
         }
 
@@ -558,7 +559,7 @@ namespace hpx { namespace traits
         {
             return local_iterator(
                 functional::lift_zipped_iterators<
-                        functional::segmented_iterator_end, iterator
+                        util::functional::segmented_iterator_end, iterator
                     >::call(iter));
         }
 
@@ -568,7 +569,8 @@ namespace hpx { namespace traits
         {
             return local_raw_iterator(
                 functional::lift_zipped_iterators<
-                        functional::segmented_iterator_local_begin, iterator
+                        util::functional::segmented_iterator_local_begin,
+                        iterator
                     >::call(seg_iter));
         }
 
@@ -578,7 +580,8 @@ namespace hpx { namespace traits
         {
             return local_raw_iterator(
                 functional::lift_zipped_iterators<
-                        functional::segmented_iterator_local_end, iterator
+                        util::functional::segmented_iterator_local_end,
+                        iterator
                     >::call(seg_iter));
         }