diff --git a/include/boost/fusion/algorithm/iteration/accumulate.hpp b/include/boost/fusion/algorithm/iteration/accumulate.hpp
index fe7112e3..7d524a15 100644
--- a/include/boost/fusion/algorithm/iteration/accumulate.hpp
+++ b/include/boost/fusion/algorithm/iteration/accumulate.hpp
@@ -1,5 +1,6 @@
 /*=============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
@@ -10,8 +11,6 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/algorithm/iteration/accumulate_fwd.hpp>
 #include <boost/fusion/algorithm/iteration/fold.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -27,11 +26,7 @@ namespace boost { namespace fusion
 
     template <typename Sequence, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence, State const, F>
-        >::type
+    inline typename result_of::accumulate<Sequence, State const, F>::type
     accumulate(Sequence& seq, State const& state, F f)
     {
         return fusion::fold(seq, state, f);
@@ -39,11 +34,7 @@ namespace boost { namespace fusion
 
     template <typename Sequence, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence const, State const, F>
-        >::type
+    inline typename result_of::accumulate<Sequence const, State const, F>::type
     accumulate(Sequence const& seq, State const& state, F f)
     {
         return fusion::fold(seq, state, f);
diff --git a/include/boost/fusion/algorithm/iteration/accumulate_fwd.hpp b/include/boost/fusion/algorithm/iteration/accumulate_fwd.hpp
index 50c4d39d..f00e67f9 100644
--- a/include/boost/fusion/algorithm/iteration/accumulate_fwd.hpp
+++ b/include/boost/fusion/algorithm/iteration/accumulate_fwd.hpp
@@ -1,5 +1,6 @@
 /*=============================================================================
     Copyright (c) 2011 Eric Niebler
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
@@ -8,8 +9,6 @@
 #define BOOST_FUSION_ACCUMULATE_FWD_HPP_INCLUDED
 
 #include <boost/fusion/support/config.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -21,20 +20,12 @@ namespace boost { namespace fusion
 
     template <typename Sequence, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence, State const, F>
-        >::type
+    inline typename result_of::accumulate<Sequence, State const, F>::type
     accumulate(Sequence& seq, State const& state, F f);
 
     template <typename Sequence, typename State, typename F>
     BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    inline typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence const, State const, F>
-        >::type
+    inline typename result_of::accumulate<Sequence const, State const, F>::type
     accumulate(Sequence const& seq, State const& state, F f);
 }}
 
diff --git a/include/boost/fusion/algorithm/iteration/detail/fold.hpp b/include/boost/fusion/algorithm/iteration/detail/fold.hpp
index 1813bd24..f7fa995b 100644
--- a/include/boost/fusion/algorithm/iteration/detail/fold.hpp
+++ b/include/boost/fusion/algorithm/iteration/detail/fold.hpp
@@ -2,6 +2,7 @@
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2006 Dan Marsden
     Copyright (c) 2009-2010 Christopher Schmidt
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
@@ -45,374 +46,121 @@ namespace boost { namespace fusion
 {
     namespace detail
     {
-        template<typename State, typename It, typename F>
-        struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)
-          : fusion::detail::result_of_with_decltype<
-                F(
-                typename add_reference<typename add_const<State>::type>::type,
-                BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It))
-            >
+        template<int SeqSize, typename It, typename State, typename F, typename = void>
+        struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)
         {};
 
-        template<typename Result,int N>
-        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)
+        template<typename It, typename State, typename F>
+        struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<0,It,State,F
+          , typename boost::enable_if_has_type<typename State::type>::type>
         {
-            template<typename State3, typename It3, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_3(State3 const& state3,It3 const& it3,F& f)
-            {
-                return BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<
-                    Result
-                  , N-4
-                >::call(
-                    f(state3,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it3)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it3),
-                    f);
-            }
-
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return call_3(
-                    f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it2),
-                    f);
-            }
-
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1),
-                    f);
-            }
-
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0),
-                    f);
-            }
+            typedef typename State::type type;
         };
 
-        template<typename Result>
-        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,3>
-        {
-            template<typename State2, typename It2, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_2(State2 const& state2,It2 const& it2,F& f)
-            {
-                return f(state2,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it2));
-            }
-
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return call_2(
-                    f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it1),
-                    f);
-            }
-
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0),
-                    f);
-            }
-        };
-
-        template<typename Result>
-        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,2>
-        {
-            template<typename State1, typename It1, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call_1(State1 const& state1,It1 const& it1,F& f)
-            {
-                return f(state1,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it1));
-            }
-
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return call_1(
-                    f(state,BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0)),
-                    fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it0),
-                    f);
-            }
-        };
-
-        template<typename Result>
-        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,1>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const& it0,F f)
-            {
-                return f(state,
-                    BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it0));
-            }
-        };
-
-        template<typename Result>
-        struct BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<Result,0>
-        {
-            template<typename State, typename It0, typename F>
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static Result
-            call(State const& state,It0 const&, F)
-            {
-                return static_cast<Result>(state);
-            }
-        };
-
-        template<typename StateRef, typename It0, typename F, int N>
-        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)
-        {
-            typedef typename
-                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                    It0 const
-                >::type
-            it1;
-            typedef typename
-                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    rest1
-                  , it1
-                  , F
-                >::type
-            rest2;
-            typedef typename
-                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<it1>::type
-            it2;
-            typedef typename
-                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    rest2
-                  , it2
-                  , F
-                >::type
-            rest3;
-            typedef typename
-                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<it2>::type
-            it3;
-
-            typedef typename
-                BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-                    typename BOOST_PP_CAT(
-                        BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                        rest3
-                      , it3
-                      , F
-                    >::type
-                  , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                        it3
-                    >::type
-                  , F
-                  , N-4
-                >::type
-            type;
-        };
-
-        template<typename StateRef, typename It0, typename F>
-        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-            StateRef
-          , It0
-          , F
-          , 3
-        >
-        {
-            typedef typename
-                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-            rest1;
-            typedef typename
-                result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                    It0 const
-                >::type
-            it1;
-
-            typedef typename
-                BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    typename BOOST_PP_CAT(
-                        BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                        rest1
-                      , it1
-                      , F
-                    >::type
-                  , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                        it1 const
-                    >::type const
-                  , F
-                >::type
-            type;
-        };
-
-        template<typename StateRef, typename It0, typename F>
-        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-            StateRef
-          , It0
-          , F
-          , 2
-        >
-          : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                typename BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                    StateRef
-                  , It0 const
-                  , F
-                >::type
-              , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                    It0 const
-                >::type const
-              , F
-            >
-        {};
-
-        template<typename StateRef, typename It0, typename F>
-        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-            StateRef
-          , It0
-          , F
-          , 1
-        >
-          : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME, _lvalue_state)<
-                StateRef
-              , It0 const
-              , F
-            >
-        {};
-
-        template<typename StateRef, typename It0, typename F>
-        struct BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-            StateRef
-          , It0
-          , F
-          , 0
-        >
-        {
-            typedef StateRef type;
-        };
-
-        template<typename StateRef, typename It0, typename F, int SeqSize>
-        struct BOOST_PP_CAT(result_of_first_unrolled,BOOST_FUSION_FOLD_NAME)
-        {
-            typedef typename
-                BOOST_PP_CAT(result_of_unrolled_,BOOST_FUSION_FOLD_NAME)<
-                    typename fusion::detail::result_of_with_decltype<
-                        F(
-                            StateRef,
-                            BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(
-                                It0 const)
-                        )
-                    >::type
-                  , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<
-                        It0 const
-                    >::type
-                  , F
-                  , SeqSize-1
-                >::type
-            type;
-        };
-
-        template<int SeqSize, typename StateRef, typename Seq, typename F>
-        struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)
-        {
-            typedef typename
-                BOOST_PP_CAT(
-                    result_of_first_unrolled,BOOST_FUSION_FOLD_NAME)<
-                    StateRef
-                  , BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(
-                        typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type
+        template<int SeqSize, typename It, typename State, typename F>
+        struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<SeqSize,It,State,F
+          , typename boost::enable_if_has_type<typename State::type>::type>
+          : BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+                SeqSize-1
+              , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<It>::type
+              , boost::result_of<
+                    F(
+                        typename State::type const&,
+                        BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It const)
                     )
-                  , F
-                  , SeqSize
-                >::type
-            type;
-
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static type
-            call(StateRef state, Seq& seq, F f)
-            {
-                typedef
-                    BOOST_PP_CAT(unrolled_,BOOST_FUSION_FOLD_NAME)<
-                        type
-                      , SeqSize
-                    >
-                unrolled_impl;
-
-                return unrolled_impl::call(
-                    state,
-                    BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(
-                        fusion::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION(seq)),
-                    f);
-            }
-        };
-
-        template<typename StateRef, typename Seq, typename F>
-        struct BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)<0,StateRef,Seq,F>
-        {
-            typedef StateRef type;
-
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            static StateRef
-            call(StateRef state, Seq&, F)
-            {
-                return static_cast<StateRef>(state);
-            }
-        };
-
-        template<typename Seq, typename State, typename F, bool IsSegmented>
-        struct BOOST_PP_CAT(result_of_, BOOST_FUSION_FOLD_NAME)
-          : BOOST_PP_CAT(BOOST_FUSION_FOLD_NAME,_impl)<
-                result_of::size<Seq>::value
-              , typename add_reference<
-                    typename add_const<State>::type
-                >::type
-              , Seq
+                >
               , F
             >
         {};
+
+        template<typename It, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+            0
+          , It
+          , State
+          , F
+        >::type
+        BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)(mpl::int_<0>, It const&, typename State::type state, F&)
+        {
+            return state;
+        }
+
+        template<typename It, typename State, typename F, int SeqSize>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename lazy_enable_if_c<
+            SeqSize != 0
+          , BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+                SeqSize
+              , It
+              , State
+              , F
+            >
+        >::type
+        BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
+        {
+            return BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)<
+                typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<It>::type
+              , boost::result_of<
+                    F(
+                        typename State::type const&,
+                        BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It const)
+                    )
+                >
+              , F
+            >(
+                mpl::int_<SeqSize-1>()
+              , fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it)
+              , f(state, BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it))
+              , f
+            );
+        }
+
+        template<typename Seq, typename State, typename F
+          , bool = traits::is_sequence<Seq>::value
+          , bool = traits::is_segmented<Seq>::value>
+        struct BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)
+        {};
+
+        template<typename Seq, typename State, typename F>
+        struct BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F, true, false>
+          : BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+                result_of::size<Seq>::value
+              , BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(
+                    typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type
+                )
+              , add_reference<typename add_const<State>::type>
+              , F
+            >
+        {};
+
+        template<typename Seq, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F>::type
+        BOOST_FUSION_FOLD_NAME(Seq& seq, State& state, F& f)
+        {
+            return BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)<
+                BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(
+                    typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type
+                )
+              , add_reference<typename add_const<State>::type>
+              , F
+            >(
+                typename result_of::size<Seq>::type()
+              , BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(
+                    fusion::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION(seq)
+                )
+              , state
+              , f
+            );
+        }
     }
 
     namespace result_of
     {
         template<typename Seq, typename State, typename F>
         struct BOOST_FUSION_FOLD_NAME
-          : detail::BOOST_PP_CAT(result_of_, BOOST_FUSION_FOLD_NAME)<
-                Seq
-              , State
-              , F
-              , traits::is_segmented<Seq>::type::value
-            >
+          : detail::BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F>
         {};
     }
 
@@ -425,10 +173,7 @@ namespace boost { namespace fusion
     >::type
     BOOST_FUSION_FOLD_NAME(Seq& seq, State const& state, F f)
     {
-        return result_of::BOOST_FUSION_FOLD_NAME<Seq,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::BOOST_FUSION_FOLD_NAME<Seq, State const, F>(seq, state, f);
     }
 
     template<typename Seq, typename State, typename F>
@@ -440,10 +185,7 @@ namespace boost { namespace fusion
     >::type
     BOOST_FUSION_FOLD_NAME(Seq const& seq, State const& state, F f)
     {
-        return result_of::BOOST_FUSION_FOLD_NAME<Seq const,State const,F>::call(
-            state,
-            seq,
-            f);
+        return detail::BOOST_FUSION_FOLD_NAME<Seq const, State const, F>(seq, state, f);
     }
 
     template<typename Seq, typename State, typename F>
@@ -455,10 +197,7 @@ namespace boost { namespace fusion
     >::type
     BOOST_FUSION_FOLD_NAME(Seq& seq, State& state, F f)
     {
-        return result_of::BOOST_FUSION_FOLD_NAME<Seq,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::BOOST_FUSION_FOLD_NAME<Seq, State, F>(seq, state, f);
     }
 
     template<typename Seq, typename State, typename F>
@@ -470,10 +209,7 @@ namespace boost { namespace fusion
     >::type
     BOOST_FUSION_FOLD_NAME(Seq const& seq, State& state, F f)
     {
-        return result_of::BOOST_FUSION_FOLD_NAME<Seq const,State,F>::call(
-            state,
-            seq,
-            f);
+        return detail::BOOST_FUSION_FOLD_NAME<Seq const, State, F>(seq, state, f);
     }
 }}
 
diff --git a/include/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp b/include/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp
index 4ff679af..350bff75 100644
--- a/include/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp
+++ b/include/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp
@@ -10,6 +10,7 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/algorithm/iteration/fold_fwd.hpp>
 #include <boost/fusion/support/segmented_fold_until.hpp>
+#include <boost/mpl/bool.hpp>
 
 namespace boost { namespace fusion { namespace detail
 {
@@ -38,11 +39,11 @@ namespace boost { namespace fusion { namespace detail
     };
 
     // The default implementation of this lives in detail/fold.hpp
-    template <typename Sequence, typename State, typename Fun, bool IsSegmented>
+    template <typename Sequence, typename State, typename Fun, bool IsSequence, bool IsSegmented>
     struct result_of_fold;
 
     template <typename Sequence, typename State, typename Fun>
-    struct result_of_fold<Sequence, State, Fun, true>
+    struct result_of_fold<Sequence, State, Fun, true, true>
     {
         typedef
             typename result_of::segmented_fold_until<
@@ -53,7 +54,7 @@ namespace boost { namespace fusion { namespace detail
         type;
 
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        static type call(State& state, Sequence& seq, Fun fun)
+        static type call(Sequence& seq, State& state, Fun& fun)
         {
             return fusion::segmented_fold_until(seq, state, segmented_fold_fun<Fun>(fun));
         }
diff --git a/include/boost/fusion/algorithm/iteration/fold.hpp b/include/boost/fusion/algorithm/iteration/fold.hpp
index a2a0146a..29748cd8 100644
--- a/include/boost/fusion/algorithm/iteration/fold.hpp
+++ b/include/boost/fusion/algorithm/iteration/fold.hpp
@@ -2,6 +2,7 @@
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2007 Dan Marsden
     Copyright (c) 2009-2010 Christopher Schmidt
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
@@ -10,23 +11,17 @@
 #define BOOST_FUSION_ALGORITHM_ITERATION_FOLD_HPP
 
 #include <boost/fusion/support/config.hpp>
-#include <boost/fusion/support/detail/result_of.hpp>
 #include <boost/fusion/algorithm/iteration/fold_fwd.hpp>
 #include <boost/config.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/end.hpp>
-#include <boost/fusion/sequence/intrinsic/empty.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/support/is_segmented.hpp>
-#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/iterator/deref.hpp>
 #include <boost/fusion/iterator/value_of.hpp>
-#include <boost/fusion/iterator/prior.hpp>
 #include <boost/fusion/iterator/next.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/bool.hpp>
 #include <boost/utility/result_of.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_reference.hpp>
 
diff --git a/include/boost/fusion/algorithm/iteration/iter_fold.hpp b/include/boost/fusion/algorithm/iteration/iter_fold.hpp
index b59a6957..952466a1 100644
--- a/include/boost/fusion/algorithm/iteration/iter_fold.hpp
+++ b/include/boost/fusion/algorithm/iteration/iter_fold.hpp
@@ -1,6 +1,7 @@
 /*=============================================================================
     Copyright (c) 2010 Christopher Schmidt
     Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
@@ -13,19 +14,14 @@
 #include <boost/fusion/algorithm/iteration/iter_fold_fwd.hpp>
 #include <boost/config.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/end.hpp>
-#include <boost/fusion/sequence/intrinsic/empty.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/support/is_segmented.hpp>
-#include <boost/fusion/support/detail/result_of.hpp>
-#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/iterator/deref.hpp>
 #include <boost/fusion/iterator/value_of.hpp>
-#include <boost/fusion/iterator/prior.hpp>
 #include <boost/fusion/iterator/next.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/bool.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_reference.hpp>
 
diff --git a/include/boost/fusion/algorithm/iteration/reverse_fold.hpp b/include/boost/fusion/algorithm/iteration/reverse_fold.hpp
index dffff79e..f2d060f3 100644
--- a/include/boost/fusion/algorithm/iteration/reverse_fold.hpp
+++ b/include/boost/fusion/algorithm/iteration/reverse_fold.hpp
@@ -1,6 +1,7 @@
 /*=============================================================================
     Copyright (c) 2010 Christopher Schmidt
     Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
@@ -10,23 +11,17 @@
 #define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_FOLD_HPP
 
 #include <boost/fusion/support/config.hpp>
-#include <boost/fusion/support/detail/result_of.hpp>
 #include <boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp>
 #include <boost/config.hpp>
-#include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/sequence/intrinsic/end.hpp>
-#include <boost/fusion/sequence/intrinsic/empty.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/support/is_segmented.hpp>
-#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/iterator/deref.hpp>
 #include <boost/fusion/iterator/value_of.hpp>
 #include <boost/fusion/iterator/prior.hpp>
-#include <boost/fusion/iterator/next.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/bool.hpp>
 #include <boost/utility/result_of.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_reference.hpp>
 
diff --git a/include/boost/fusion/algorithm/iteration/reverse_iter_fold.hpp b/include/boost/fusion/algorithm/iteration/reverse_iter_fold.hpp
index d36861f3..85abf12f 100644
--- a/include/boost/fusion/algorithm/iteration/reverse_iter_fold.hpp
+++ b/include/boost/fusion/algorithm/iteration/reverse_iter_fold.hpp
@@ -1,6 +1,7 @@
 /*=============================================================================
     Copyright (c) 2010 Christopher Schmidt
     Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2015 Kohei Takahashi
 
     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)
@@ -9,23 +10,17 @@
 #define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_ITER_FOLD_HPP
 
 #include <boost/fusion/support/config.hpp>
-#include <boost/fusion/support/detail/result_of.hpp>
 #include <boost/fusion/algorithm/iteration/reverse_iter_fold_fwd.hpp>
 #include <boost/config.hpp>
-#include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/sequence/intrinsic/end.hpp>
-#include <boost/fusion/sequence/intrinsic/empty.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/support/is_segmented.hpp>
-#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/iterator/deref.hpp>
 #include <boost/fusion/iterator/value_of.hpp>
 #include <boost/fusion/iterator/prior.hpp>
-#include <boost/fusion/iterator/next.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/bool.hpp>
 #include <boost/utility/result_of.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_reference.hpp>
 
diff --git a/include/boost/fusion/support/detail/result_of.hpp b/include/boost/fusion/support/detail/result_of.hpp
deleted file mode 100644
index e53ea9e3..00000000
--- a/include/boost/fusion/support/detail/result_of.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2014 Joel de Guzman
-
-    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(FUSION_RESULT_OF_10272014_0654)
-#define FUSION_RESULT_OF_10272014_0654
-
-#include <boost/config.hpp>
-#include <boost/utility/result_of.hpp>
-
-#if !defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#define BOOST_FUSION_NO_DECLTYPE_BASED_RESULT_OF
-#endif
-
-#if !defined(BOOST_FUSION_NO_DECLTYPE_BASED_RESULT_OF)
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/has_xxx.hpp>
-#endif
-
-namespace boost { namespace fusion { namespace detail
-{
-    // This is a temporary workaround for result_of before we make fusion fully
-    // sfinae result_of friendy, which will require some heavy lifting for some
-    // low level code. So far this is used only in the fold algorithm. This will
-    // be removed once we overhaul fold.
-
-#if defined(BOOST_FUSION_NO_DECLTYPE_BASED_RESULT_OF)
-
-    template <typename Sig>
-    struct result_of_with_decltype : boost::tr1_result_of<Sig> {};
-
-#else // defined(BOOST_FUSION_NO_DECLTYPE_BASED_RESULT_OF)
-
-    BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
-    BOOST_MPL_HAS_XXX_TEMPLATE_DEF(result)
-
-    template <typename Sig>
-    struct result_of_with_decltype;
-
-    template <typename F, typename... Args>
-    struct result_of_with_decltype<F(Args...)>
-        : mpl::if_<mpl::or_<has_result_type<F>, detail::has_result<F> >,
-            boost::tr1_result_of<F(Args...)>,
-            boost::detail::cpp0x_result_of<F(Args...)> >::type {};
-
-#endif // defined(BOOST_FUSION_NO_DECLTYPE_BASED_RESULT_OF)
-
-}}}
-
-#endif
diff --git a/include/boost/fusion/support/segmented_fold_until.hpp b/include/boost/fusion/support/segmented_fold_until.hpp
index 9e6f4a50..8fb09ee3 100644
--- a/include/boost/fusion/support/segmented_fold_until.hpp
+++ b/include/boost/fusion/support/segmented_fold_until.hpp
@@ -11,11 +11,6 @@
 #include <boost/type_traits/is_const.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/fusion/support/detail/segmented_fold_until_impl.hpp>
-#include <boost/fusion/view/iterator_range.hpp>
-#include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/end.hpp>
-#include <boost/fusion/sequence/intrinsic/empty.hpp>
-#include <boost/fusion/container/list/cons.hpp>
 
 namespace boost { namespace fusion
 {
diff --git a/test/algorithm/fold.cpp b/test/algorithm/fold.cpp
index 249f1bb3..c441ceaf 100644
--- a/test/algorithm/fold.cpp
+++ b/test/algorithm/fold.cpp
@@ -238,7 +238,7 @@ main()
     }
 
     {
-#if !defined(BOOST_FUSION_NO_DECLTYPE_BASED_RESULT_OF)
+#if defined(BOOST_RESULT_OF_USE_DECLTYPE)
         {
             boost::fusion::vector<int, double, long> container{1, 2, 3};
             functor f;
diff --git a/test/compile_time/sfinae_friendly.hpp b/test/compile_time/sfinae_friendly.hpp
index 77b148b8..1111cd8c 100644
--- a/test/compile_time/sfinae_friendly.hpp
+++ b/test/compile_time/sfinae_friendly.hpp
@@ -12,9 +12,9 @@
 #include <boost/config.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/assert.hpp>
-#include <boost/fusion/support/detail/result_of.hpp>
+#include <boost/utility/result_of.hpp>
 
-#if !defined(BOOST_NO_SFINAE) && !defined(BOOST_FUSION_NO_DECLTYPE_BASED_RESULT_OF)
+#if !defined(BOOST_NO_SFINAE) && defined(BOOST_RESULT_OF_USE_DECLTYPE)
 
 #include <boost/fusion/container/vector.hpp>