diff --git a/include/boost/fusion/algorithm/iteration/ext_/fold_s.hpp b/include/boost/fusion/algorithm/iteration/ext_/fold_s.hpp
index f991d03c..9e9c3456 100644
--- a/include/boost/fusion/algorithm/iteration/ext_/fold_s.hpp
+++ b/include/boost/fusion/algorithm/iteration/ext_/fold_s.hpp
@@ -12,18 +12,18 @@
 
 namespace boost { namespace fusion { namespace detail
 {
-    template<typename Fun>
+    template <typename Fun>
     struct segmented_fold_fun
     {
-        template<typename Sig>
+        template <typename Sig>
         struct result;
 
-        template<typename This, typename Range, typename State, typename Context>
-        struct result<This(Range&, State&, Context&)>
+        template <typename This, typename Sequence, typename State, typename Context>
+        struct result<This(Sequence&, State&, Context&)>
         {
             typedef
                 fusion::result<
-                    typename result_of::fold<Range, State, Fun>::type,
+                    typename result_of::fold<Sequence, State, Fun>::type,
                     continue_
                 >
             type;
@@ -33,11 +33,11 @@ namespace boost { namespace fusion { namespace detail
           : fun(f)
         {}
 
-        template<typename Range, typename State, typename Context>
-        typename result<segmented_fold_fun(Range&, State const&, Context const&)>::type
-        operator()(Range& rng, State const& state, Context const&) const
+        template <typename Sequence, typename State, typename Context>
+        typename result<segmented_fold_fun(Sequence&, State const&, Context const&)>::type
+        operator()(Sequence& seq, State const& state, Context const&) const
         {
-            return fusion::fold(rng, state, fun);
+            return fusion::fold(seq, state, fun);
         }
 
         Fun const& fun;
diff --git a/include/boost/fusion/algorithm/iteration/ext_/for_each_s.hpp b/include/boost/fusion/algorithm/iteration/ext_/for_each_s.hpp
index 8d9173aa..8158a986 100644
--- a/include/boost/fusion/algorithm/iteration/ext_/for_each_s.hpp
+++ b/include/boost/fusion/algorithm/iteration/ext_/for_each_s.hpp
@@ -13,7 +13,7 @@
 
 namespace boost { namespace fusion { namespace detail
 {
-    template<typename Fun>
+    template <typename Fun>
     struct segmented_for_each_fun
     {
         typedef result<void, continue_> result_type;
@@ -22,10 +22,10 @@ namespace boost { namespace fusion { namespace detail
           : fun(f)
         {}
 
-        template<typename Range, typename State, typename Context>
-        result_type operator()(Range& rng, State const&, Context const&) const
+        template <typename Sequence, typename State, typename Context>
+        result_type operator()(Sequence& seq, State const&, Context const&) const
         {
-            fusion::for_each(rng, fun);
+            fusion::for_each(seq, fun);
             return void_();
         }
 
diff --git a/include/boost/fusion/algorithm/query/detail/find_if.hpp b/include/boost/fusion/algorithm/query/detail/find_if.hpp
index 5d2a7419..db2c182a 100644
--- a/include/boost/fusion/algorithm/query/detail/find_if.hpp
+++ b/include/boost/fusion/algorithm/query/detail/find_if.hpp
@@ -9,19 +9,18 @@
 #if !defined(FUSION_FIND_IF_05052005_1107)
 #define FUSION_FIND_IF_05052005_1107
 
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/lambda.hpp>
 #include <boost/mpl/apply.hpp>
+#include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/identity.hpp>
+#include <boost/mpl/lambda.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/distance.hpp>
 #include <boost/fusion/iterator/equal_to.hpp>
 #include <boost/fusion/iterator/next.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/iterator/advance.hpp>
-#include <boost/fusion/iterator/distance.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
 #include <boost/fusion/support/category_of.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
 
 namespace boost { namespace fusion { 
     struct random_access_traversal_tag;
@@ -222,10 +221,31 @@ namespace detail
 
         template <typename Iterator>
         static type
-        call(Iterator const& iter)
+        iter_call(Iterator const& iter)
         {
             return choose_call(iter, typename traits::category_of<Iterator>::type());
         }
+
+        template <typename Sequence>
+        static type
+        call(Sequence& seq)
+        {
+            return iter_call(fusion::begin(seq));
+        }
+    };
+
+    template <typename Sequence, typename Pred>
+    struct result_of_find_if
+    {
+        typedef
+            static_find_if<
+                typename result_of::begin<Sequence>::type
+              , typename result_of::end<Sequence>::type
+              , Pred
+            >
+        filter;
+
+        typedef typename filter::type type;
     };
 }}}
 
diff --git a/include/boost/fusion/algorithm/query/detail/segmented_find.hpp b/include/boost/fusion/algorithm/query/detail/segmented_find.hpp
new file mode 100644
index 00000000..8429022e
--- /dev/null
+++ b/include/boost/fusion/algorithm/query/detail/segmented_find.hpp
@@ -0,0 +1,106 @@
+/*=============================================================================
+    Copyright (c) 2011 Eric Niebler
+
+    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(BOOST_FUSION_SEGMENTED_FIND_HPP_INCLUDED)
+#define BOOST_FUSION_SEGMENTED_FIND_HPP_INCLUDED
+
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/fusion/algorithm/query/find_fwd.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/support/segmented_fold_until.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename T>
+    struct segmented_find_fun
+    {
+        template <typename Sig>
+        struct result;
+
+        template <typename This, typename Sequence, typename State, typename Context>
+        struct result<This(Sequence&, State&, Context&)>
+        {
+            typedef
+                typename result_of::find<Sequence, T>::type
+            iterator_type;
+
+            typedef
+                typename result_of::make_segmented_iterator<
+                    iterator_type
+                  , typename remove_const<Context>::type
+                >::type
+            segmented_iterator_type;
+
+            typedef
+                typename mpl::if_<
+                    result_of::equal_to<
+                        iterator_type
+                      , typename result_of::end<Sequence>::type
+                    >
+                  , fusion::result<typename remove_const<State>::type, continue_>,  // NOT FOUND
+                    fusion::result<segmented_iterator_type, break_>                 // FOUND
+                >::type
+            type;
+        };
+
+        template <typename Sequence, typename State, typename Context>
+        typename result<segmented_find_fun(Sequence&, State const&, Context const&)>::type
+        operator()(Sequence& seq, State const&state, Context const& context) const
+        {
+            typedef
+                typename result_of::equal_to<
+                    typename result_of::find<Sequence, T>::type
+                  , typename result_of::end<Sequence>::type
+                >::type
+            not_found;
+
+            return call(seq, state, context, not_found());
+        }
+
+    private:
+        template <typename Sequence, typename State, typename Context>
+        typename result<segmented_find_fun(Sequence&, State const&, Context const&)>::type
+        call(Sequence&, State const&state, Context const&, mpl::true_) const
+        {
+            return state;
+        }
+
+        template <typename Sequence, typename State, typename Context>
+        typename result<segmented_find_fun(Sequence&, State const&, Context const&)>::type
+        call(Sequence& seq, State const&, Context const& context, mpl::false_) const
+        {
+            return fusion::make_segmented_iterator(fusion::find<T>(seq), context);
+        }
+    };
+
+    template <typename Sequence, typename T>
+    struct result_of_segmented_find
+    {
+        struct filter
+        {
+            typedef
+                typename result_of::segmented_fold_until<
+                    Sequence
+                  , typename result_of::end<Sequence>::type
+                  , segmented_find_fun<T>
+                >::type
+            type;
+
+            static type call(Sequence& seq)
+            {
+                return fusion::segmented_fold_until(
+                    seq
+                  , fusion::end(seq)
+                  , detail::segmented_find_fun<T>());
+            }
+        };
+
+        typedef typename filter::type type;
+    };
+}}}
+
+#endif
diff --git a/include/boost/fusion/algorithm/query/detail/segmented_find_if.hpp b/include/boost/fusion/algorithm/query/detail/segmented_find_if.hpp
new file mode 100644
index 00000000..bdbbcfbc
--- /dev/null
+++ b/include/boost/fusion/algorithm/query/detail/segmented_find_if.hpp
@@ -0,0 +1,108 @@
+/*=============================================================================
+    Copyright (c) 2011 Eric Niebler
+
+    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(BOOST_FUSION_SEGMENTED_FIND_IF_HPP_INCLUDED)
+#define BOOST_FUSION_SEGMENTED_FIND_IF_HPP_INCLUDED
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/fusion/algorithm/query/find_if_fwd.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/support/segmented_fold_until.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Pred>
+    struct segmented_find_if_fun
+    {
+        template <typename Sig>
+        struct result;
+
+        template <typename This, typename Sequence, typename State, typename Context>
+        struct result<This(Sequence&, State&, Context&)>
+        {
+            typedef
+                typename result_of::find_if<Sequence, Pred>::type
+            iterator_type;
+
+            typedef
+                typename result_of::make_segmented_iterator<
+                    iterator_type
+                  , typename remove_const<Context>::type
+                >::type
+            segmented_iterator_type;
+
+            typedef
+                typename mpl::if_<
+                    result_of::equal_to<
+                        iterator_type
+                      , typename result_of::end<Sequence>::type
+                    >
+                  , fusion::result<typename remove_const<State>::type, continue_>, // NOT FOUND
+                    fusion::result<segmented_iterator_type, break_>                // FOUND
+                >::type
+            type;
+        };
+
+        template <typename Sequence, typename State, typename Context>
+        typename result<segmented_find_if_fun(Sequence&, State const&, Context const&)>::type
+        operator()(Sequence& seq, State const& state, Context const& context) const
+        {
+            typedef
+                typename result_of::equal_to<
+                    typename result_of::find_if<Sequence, Pred>::type
+                  , typename result_of::end<Sequence>::type
+                >::type
+            not_found;
+
+            return call(seq, state, context, not_found());
+        }
+
+    private:
+        template <typename Sequence, typename State, typename Context>
+        typename result<segmented_find_if_fun(Sequence&, State const&, Context const&)>::type
+        call(Sequence&, State const& state, Context const&, mpl::true_) const
+        {
+            return state;
+        }
+
+        template <typename Sequence, typename State, typename Context>
+        typename result<segmented_find_if_fun(Sequence&, State const&, Context const&)>::type
+        call(Sequence& seq, State const&, Context const& context, mpl::false_) const
+        {
+            return fusion::make_segmented_iterator(fusion::find_if<Pred>(seq), context);
+        }
+    };
+
+    template <typename Sequence, typename Pred>
+    struct result_of_segmented_find_if
+    {
+        struct filter
+        {
+            typedef
+                typename result_of::segmented_fold_until<
+                    Sequence
+                  , typename result_of::end<Sequence>::type
+                  , segmented_find_if_fun<Pred>
+                >::type
+            type;
+
+            static type call(Sequence& seq)
+            {
+                return fusion::segmented_fold_until(
+                    seq
+                  , fusion::end(seq)
+                  , segmented_find_if_fun<Pred>());
+            }
+        };
+
+        typedef typename filter::type type;
+    };
+}}}
+
+#endif
diff --git a/include/boost/fusion/algorithm/query/ext_/find_if_s.hpp b/include/boost/fusion/algorithm/query/ext_/find_if_s.hpp
deleted file mode 100644
index 863d806a..00000000
--- a/include/boost/fusion/algorithm/query/ext_/find_if_s.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2011 Eric Niebler
-
-    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(BOOST_FUSION_FIND_IF_S_HPP_INCLUDED)
-#define BOOST_FUSION_FIND_IF_S_HPP_INCLUDED
-
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/fusion/algorithm/query/find_if.hpp>
-#include <boost/fusion/sequence/intrinsic/end.hpp>
-#include <boost/fusion/support/segmented_fold_until.hpp>
-
-namespace boost { namespace fusion { namespace detail
-{
-    template<typename Pred>
-    struct segmented_find_if_fun
-    {
-        template<typename Sig>
-        struct result;
-
-        template<typename This, typename Range, typename State, typename Context>
-        struct result<This(Range&, State&, Context&)>
-        {
-            typedef
-                typename result_of::find_if<Range, Pred>::type
-            iterator_type;
-
-            typedef
-                typename result_of::make_segmented_iterator<
-                    iterator_type,
-                    typename remove_const<Context>::type
-                >::type
-            segmented_iterator_type;
-
-            typedef
-                typename mpl::if_<
-                    result_of::equal_to<
-                        iterator_type,
-                        typename result_of::end<Range>::type
-                    >,
-                    fusion::result<typename remove_const<State>::type, continue_>, // NOT FOUND
-                    fusion::result<segmented_iterator_type, break_>     // FOUND
-                >::type
-            type;
-        };
-
-        template<typename Range, typename State, typename Context>
-        typename result<segmented_find_if_fun(Range&, State const&, Context const&)>::type
-        operator()(Range& rng, State const& state, Context const& context) const
-        {
-            typedef
-                typename result_of::equal_to<
-                    typename result_of::find_if<Range, Pred>::type,
-                    typename result_of::end<Range>::type
-                >::type
-            not_found;
-
-            return call(rng, state, context, not_found());
-        }
-
-    private:
-        template<typename Range, typename State, typename Context>
-        typename result<segmented_find_if_fun(Range&, State const&, Context const&)>::type
-        call(Range&, State const& state, Context const&, mpl::true_) const
-        {
-            return state;
-        }
-
-        template<typename Range, typename State, typename Context>
-        typename result<segmented_find_if_fun(Range&, State const&, Context const&)>::type
-        call(Range& rng, State const&, Context const& context, mpl::false_) const
-        {
-            return fusion::make_segmented_iterator(fusion::find_if<Pred>(rng), context);
-        }
-    };
-
-}}}
-
-namespace boost { namespace fusion
-{
-    namespace result_of
-    {
-        template <typename Sequence, typename Pred>
-        struct find_if_s
-          : result_of::segmented_fold_until<
-                Sequence,
-                typename result_of::end<Sequence>::type,
-                detail::segmented_find_if_fun<Pred> >
-        {};
-    }
-
-    template <typename Pred, typename Sequence>
-    typename result_of::find_if_s<Sequence, Pred>::type
-    find_if_s(Sequence& seq)
-    {
-        return fusion::segmented_fold_until(
-            seq,
-            fusion::end(seq),
-            detail::segmented_find_if_fun<Pred>());
-    }
-
-    template <typename Pred, typename Sequence>
-    typename result_of::find_if_s<Sequence const, Pred>::type
-    find_if_s(Sequence const& seq)
-    {
-        return fusion::segmented_fold_until(
-            seq, fusion::end(seq),
-            detail::segmented_find_if_fun<Pred>());
-    }
-}}
-
-#endif
diff --git a/include/boost/fusion/algorithm/query/ext_/find_s.hpp b/include/boost/fusion/algorithm/query/ext_/find_s.hpp
deleted file mode 100644
index a1a1f904..00000000
--- a/include/boost/fusion/algorithm/query/ext_/find_s.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2011 Eric Niebler
-
-    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(BOOST_FUSION_FIND_S_HPP_INCLUDED)
-#define BOOST_FUSION_FIND_S_HPP_INCLUDED
-
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/fusion/algorithm/query/find.hpp>
-#include <boost/fusion/sequence/intrinsic/end.hpp>
-#include <boost/fusion/support/segmented_fold_until.hpp>
-
-namespace boost { namespace fusion { namespace detail
-{
-    template<typename T>
-    struct segmented_find_fun
-    {
-        template<typename Sig>
-        struct result;
-
-        template<typename This, typename Range, typename State, typename Context>
-        struct result<This(Range&, State&, Context&)>
-        {
-            typedef
-                typename result_of::find<Range, T>::type
-            iterator_type;
-
-            typedef
-                typename result_of::make_segmented_iterator<
-                    iterator_type,
-                    typename remove_const<Context>::type
-                >::type
-            segmented_iterator_type;
-
-            typedef
-                typename mpl::if_<
-                    result_of::equal_to<
-                        iterator_type,
-                        typename result_of::end<Range>::type
-                    >,
-                    fusion::result<typename remove_const<State>::type, continue_>, // NOT FOUND
-                    fusion::result<segmented_iterator_type, break_>     // FOUND
-                >::type
-            type;
-        };
-
-        template<typename Range, typename State, typename Context>
-        typename result<segmented_find_fun(Range&, State const&, Context const&)>::type
-        operator()(Range& rng, State const&state, Context const& context) const
-        {
-            typedef
-                typename result_of::equal_to<
-                    typename result_of::find<Range, T>::type,
-                    typename result_of::end<Range>::type
-                >::type
-            not_found;
-
-            return call(rng, state, context, not_found());
-        }
-
-    private:
-        template<typename Range, typename State, typename Context>
-        typename result<segmented_find_fun(Range&, State const&, Context const&)>::type
-        call(Range&, State const&state, Context const&, mpl::true_) const
-        {
-            return state;
-        }
-
-        template<typename Range, typename State, typename Context>
-        typename result<segmented_find_fun(Range&, State const&, Context const&)>::type
-        call(Range& rng, State const&, Context const& context, mpl::false_) const
-        {
-            return fusion::make_segmented_iterator(fusion::find<T>(rng), context);
-        }
-    };
-
-}}}
-
-namespace boost { namespace fusion
-{
-    namespace result_of
-    {
-        template <typename Sequence, typename T>
-        struct find_s
-          : result_of::segmented_fold_until<
-                Sequence,
-                typename result_of::end<Sequence>::type,
-                detail::segmented_find_fun<T> >
-        {};
-    }
-
-    template <typename T, typename Sequence>
-    typename result_of::find_s<Sequence, T>::type
-    find_s(Sequence& seq)
-    {
-        return fusion::segmented_fold_until(
-            seq,
-            fusion::end(seq),
-            detail::segmented_find_fun<T>());
-    }
-
-    template <typename T, typename Sequence>
-    typename result_of::find_s<Sequence const, T>::type
-    find_s(Sequence const& seq)
-    {
-        return fusion::segmented_fold_until(
-            seq,
-            fusion::end(seq),
-            detail::segmented_find_fun<T>());
-    }
-}}
-
-#endif
diff --git a/include/boost/fusion/algorithm/query/find.hpp b/include/boost/fusion/algorithm/query/find.hpp
index 6beb9005..7b089c96 100644
--- a/include/boost/fusion/algorithm/query/find.hpp
+++ b/include/boost/fusion/algorithm/query/find.hpp
@@ -1,5 +1,6 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
+    Copyright (c) 2011 Eric Niebler
 
     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)
@@ -7,13 +8,15 @@
 #if !defined(FUSION_FIND_05052005_1107)
 #define FUSION_FIND_05052005_1107
 
+#include <boost/fusion/algorithm/query/find_if_fwd.hpp>
 #include <boost/fusion/algorithm/query/detail/find_if.hpp>
-#include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/algorithm/query/detail/segmented_find.hpp>
 #include <boost/fusion/iterator/key_of.hpp>
 #include <boost/fusion/iterator/value_of.hpp>
 #include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
 #include <boost/mpl/if.hpp>
+#include <boost/mpl/placeholders.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/utility/enable_if.hpp>
@@ -22,17 +25,14 @@ namespace boost { namespace fusion
 {
     namespace result_of
     {
-        template <
-            typename Sequence
-          , typename T
-        >
+        template <typename Sequence, typename T>
         struct find
-        {
-            typedef
-                detail::static_find_if<
-                    typename result_of::begin<Sequence>::type
-                  , typename result_of::end<Sequence>::type
-                  , is_same<
+          : mpl::if_<
+                traits::is_segmented<Sequence>
+              , detail::result_of_segmented_find<Sequence, T>
+              , detail::result_of_find_if<
+                    Sequence,
+                    is_same<
                         typename mpl::if_<
                             traits::is_associative<Sequence>
                           , key_of<mpl::_1>
@@ -41,10 +41,8 @@ namespace boost { namespace fusion
                       , T
                     >
                 >
-            filter;
-
-            typedef typename filter::type type;
-        };
+            >::type
+        {};
     }
 
     template <typename T, typename Sequence>
@@ -56,7 +54,7 @@ namespace boost { namespace fusion
     find(Sequence& seq)
     {
         typedef typename result_of::find<Sequence, T>::filter filter;
-        return filter::call(fusion::begin(seq));
+        return filter::call(seq);
     }
 
     template <typename T, typename Sequence>
@@ -64,9 +62,8 @@ namespace boost { namespace fusion
     find(Sequence const& seq)
     {
         typedef typename result_of::find<Sequence const, T>::filter filter;
-        return filter::call(fusion::begin(seq));
+        return filter::call(seq);
     }
 }}
 
 #endif
-
diff --git a/include/boost/fusion/algorithm/query/find_fwd.hpp b/include/boost/fusion/algorithm/query/find_fwd.hpp
new file mode 100644
index 00000000..96d989a4
--- /dev/null
+++ b/include/boost/fusion/algorithm/query/find_fwd.hpp
@@ -0,0 +1,34 @@
+/*=============================================================================
+    Copyright (c) 2011 Eric Niebler
+
+    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(BOOST_FUSION_FIND_FWD_HPP_INCLUDED)
+#define BOOST_FUSION_FIND_FWD_HPP_INCLUDED
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct find;
+    }
+
+    template <typename T, typename Sequence>
+    inline typename 
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find<Sequence, T>
+        >::type const
+    find(Sequence& seq);
+
+    template <typename T, typename Sequence>
+    inline typename result_of::find<Sequence const, T>::type const
+    find(Sequence const& seq);
+}}
+
+#endif
diff --git a/include/boost/fusion/algorithm/query/find_if.hpp b/include/boost/fusion/algorithm/query/find_if.hpp
index 3950958c..5f0e64d8 100644
--- a/include/boost/fusion/algorithm/query/find_if.hpp
+++ b/include/boost/fusion/algorithm/query/find_if.hpp
@@ -1,5 +1,6 @@
 /*=============================================================================
     Copyright (c) 2001-2006 Joel de Guzman
+    Copyright (c) 2011 Eric Niebler
 
     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)
@@ -7,15 +8,17 @@
 #if !defined(FUSION_FIND_IF_05052005_1108)
 #define FUSION_FIND_IF_05052005_1108
 
+#include <boost/fusion/algorithm/query/find_if_fwd.hpp>
 #include <boost/fusion/algorithm/query/detail/find_if.hpp>
-#include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/algorithm/query/detail/segmented_find_if.hpp>
 #include <boost/fusion/iterator/value_of.hpp>
-#include <boost/mpl/bind.hpp>
-#include <boost/mpl/lambda.hpp>
-#include <boost/mpl/quote.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/bind.hpp>
+#include <boost/mpl/lambda.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/quote.hpp>
 
 namespace boost { namespace fusion
 {
@@ -23,20 +26,18 @@ namespace boost { namespace fusion
     {
         template <typename Sequence, typename Pred>
         struct find_if
-        {
-            typedef
-                detail::static_find_if<
-                    typename result_of::begin<Sequence>::type
-                  , typename result_of::end<Sequence>::type
-                  , mpl::bind1<
+          : mpl::if_<
+                traits::is_segmented<Sequence>
+              , detail::result_of_segmented_find_if<Sequence, Pred>
+              , detail::result_of_find_if<
+                    Sequence,
+                    mpl::bind1<
                         typename mpl::lambda<Pred>::type
-                      , mpl::bind1<mpl::quote1<value_of>,mpl::_1>
+                      , mpl::bind1<mpl::quote1<value_of>, mpl::_1>
                     >
                 >
-            filter;
-
-            typedef typename filter::type type;
-        };
+            >::type
+        {};
     }
 
     template <typename Pred, typename Sequence>
@@ -48,7 +49,7 @@ namespace boost { namespace fusion
     find_if(Sequence& seq)
     {
         typedef typename result_of::find_if<Sequence, Pred>::filter filter;
-        return filter::call(fusion::begin(seq));
+        return filter::call(seq);
     }
 
     template <typename Pred, typename Sequence>
@@ -56,9 +57,8 @@ namespace boost { namespace fusion
     find_if(Sequence const& seq)
     {
         typedef typename result_of::find_if<Sequence const, Pred>::filter filter;
-        return filter::call(fusion::begin(seq));
+        return filter::call(seq);
     }
 }}
 
 #endif
-
diff --git a/include/boost/fusion/algorithm/query/find_if_fwd.hpp b/include/boost/fusion/algorithm/query/find_if_fwd.hpp
new file mode 100644
index 00000000..adb8f2de
--- /dev/null
+++ b/include/boost/fusion/algorithm/query/find_if_fwd.hpp
@@ -0,0 +1,35 @@
+/*=============================================================================
+    Copyright (c) 2011 Eric Niebler
+
+    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(BOOST_FUSION_FIND_IF_FWD_HPP_INCLUDED)
+#define BOOST_FUSION_FIND_IF_FWD_HPP_INCLUDED
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+// Forward declaration of find_if algorithm
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Pred>
+        struct find_if;
+    }
+
+    template <typename Pred, typename Sequence>
+    typename 
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find_if<Sequence, Pred>
+        >::type
+    find_if(Sequence& seq);
+
+    template <typename Pred, typename Sequence>
+    typename result_of::find_if<Sequence const, Pred>::type const
+    find_if(Sequence const& seq);
+}}
+
+#endif
diff --git a/include/boost/fusion/iterator/detail/segmented_next_impl.hpp b/include/boost/fusion/iterator/detail/segmented_next_impl.hpp
index 60ead2e5..2a7f6f6c 100644
--- a/include/boost/fusion/iterator/detail/segmented_next_impl.hpp
+++ b/include/boost/fusion/iterator/detail/segmented_next_impl.hpp
@@ -24,7 +24,7 @@ namespace boost { namespace fusion
 
     namespace detail
     {
-        template <typename Range, typename Stack>
+        template <typename Sequence, typename Stack>
         struct segmented_begin_impl;
 
         //bool is_invalid(stack)
@@ -40,7 +40,7 @@ namespace boost { namespace fusion
             >
         {};
 
-        ////Advance the first iterator in the range at the
+        ////Advance the first iterator in the seq at the
         ////top of a stack of iterator ranges. Return the
         ////new stack.
         //auto pop_front_car(stack)
@@ -126,7 +126,7 @@ namespace boost { namespace fusion
 
         template <
             typename Stack,
-            typename Range  =
+            typename Sequence  =
                 typename remove_reference<
                     typename add_const<
                         typename result_of::deref<
@@ -135,7 +135,7 @@ namespace boost { namespace fusion
                     >::type
                 >::type,
             typename Result =
-                typename segmented_begin_impl<Range, Stack>::type,
+                typename segmented_begin_impl<Sequence, Stack>::type,
             bool IsInvalid  =
                 is_invalid<Result>::value>
         struct segmented_next_impl_recurse2
@@ -149,14 +149,14 @@ namespace boost { namespace fusion
             }
         };
 
-        template <typename Stack, typename Range, typename Result>
-        struct segmented_next_impl_recurse2<Stack, Range, Result, false>
+        template <typename Stack, typename Sequence, typename Result>
+        struct segmented_next_impl_recurse2<Stack, Sequence, Result, false>
         {
             typedef Result type;
 
             static type call(Stack const & stack)
             {
-                return segmented_begin_impl<Range, Stack>::call(*stack.car.first, stack);
+                return segmented_begin_impl<Sequence, Stack>::call(*stack.car.first, stack);
             }
         };
 
@@ -210,7 +210,7 @@ namespace boost { namespace fusion
 
         //auto segmented_next_impl(stack)
         //{
-        //  // car(stack) is a range of values, not a range of segments
+        //  // car(stack) is a seq of values, not a seq of segments
         //  auto next = pop_front_car(stack);
         //  if (is_invalid(next))
         //    return segmented_next_impl_recurse(cdr(next));
diff --git a/include/boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp b/include/boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp
index b1c5b907..2e407c6b 100644
--- a/include/boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp
+++ b/include/boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp
@@ -12,24 +12,24 @@
 
 namespace boost { namespace fusion { namespace detail
 {
-    //auto segmented_begin( rng )
+    //auto segmented_begin( seq )
     //{
-    //    return make_segmented_iterator( segmented_begin_impl( rng, nil ) );
+    //    return make_segmented_iterator( segmented_begin_impl( seq, nil ) );
     //}
 
-    template<typename Range>
+    template <typename Sequence>
     struct segmented_begin
     {
         typedef
             segmented_iterator<
-                typename segmented_begin_impl<Range, fusion::nil>::type
+                typename segmented_begin_impl<Sequence, fusion::nil>::type
             >
         type;
 
-        static type call(Range & rng)
+        static type call(Sequence& seq)
         {
             return type(
-                segmented_begin_impl<Range, fusion::nil>::call(rng, fusion::nil()));
+                segmented_begin_impl<Sequence, fusion::nil>::call(seq, fusion::nil()));
         }
     };
 
diff --git a/include/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp b/include/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp
index d75a1e77..5968cd12 100644
--- a/include/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp
+++ b/include/boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp
@@ -27,80 +27,80 @@ namespace boost { namespace fusion { namespace detail
         template <typename Sig>
         struct result;
     
-        template <typename This, typename Range, typename State, typename Context>
-        struct result<This(Range&, State&, Context&)>
+        template <typename This, typename Sequence, typename State, typename Context>
+        struct result<This(Sequence&, State&, Context&)>
         {
             typedef
                 iterator_range<
-                    typename fusion::result_of::begin<Range>::type,
-                    typename fusion::result_of::end<Range>::type
+                    typename fusion::result_of::begin<Sequence>::type
+                  , typename fusion::result_of::end<Sequence>::type
                 >
             range_type;
 
             typedef
                 fusion::result<
-                    cons<range_type, typename remove_const<Context>::type>,
-                    fusion::break_
+                    cons<range_type, typename remove_const<Context>::type>
+                  , fusion::break_
                 >
             type;
         };
 
-        template <typename Range, typename State, typename Context>
-        typename result<segmented_begin_fun(Range&, State const&, Context const&)>::type
-        operator()(Range& rng, State const&, Context const& context) const
+        template <typename Sequence, typename State, typename Context>
+        typename result<segmented_begin_fun(Sequence&, State const&, Context const&)>::type
+        operator()(Sequence& seq, State const&, Context const& context) const
         {
             typedef
                 iterator_range<
-                    typename fusion::result_of::begin<Range>::type,
-                    typename fusion::result_of::end<Range>::type
+                    typename fusion::result_of::begin<Sequence>::type
+                  , typename fusion::result_of::end<Sequence>::type
                 >
             range_type;
 
-            return cons<range_type, Context>(range_type(fusion::begin(rng), fusion::end(rng)), context);
+            return cons<range_type, Context>(range_type(fusion::begin(seq), fusion::end(seq)), context);
         }
     };
 
-    template <typename Range, typename Stack, bool IsSegmented = traits::is_segmented<Range>::type::value>
+    template <typename Sequence, typename Stack, bool IsSegmented = traits::is_segmented<Sequence>::type::value>
     struct segmented_begin_impl_aux
     {
         typedef
-            segmented_end_impl<Range, Stack>
+            segmented_end_impl<Sequence, Stack>
         end_impl;
 
         typedef
             segmented_fold_until_impl<
-                Range,
-                result<typename end_impl::type, continue_>,
-                Stack,
-                segmented_begin_fun
+                Sequence
+              , result<typename end_impl::type, continue_>
+              , Stack
+              , segmented_begin_fun
             >
         fold_impl;
 
         typedef typename fold_impl::type::value_type type;
 
-        static type call(Range& rng, Stack const& stack)
+        static type call(Sequence& seq, Stack const& stack)
         {
-            return fold_impl::call(rng, end_impl::call(rng, stack), stack, segmented_begin_fun()).value;
+            return fold_impl::call(seq, end_impl::call(seq, stack), stack, segmented_begin_fun()).value;
         }
     };
 
-    template <typename Range, typename Stack>
-    struct segmented_begin_impl_aux<Range, Stack, false>
+    template <typename Sequence, typename Stack>
+    struct segmented_begin_impl_aux<Sequence, Stack, false>
     {
-        typedef typename result_of::begin<Range>::type  begin_type;
-        typedef typename result_of::end<Range>::type    end_type;
+        typedef typename result_of::begin<Sequence>::type  begin_type;
+        typedef typename result_of::end<Sequence>::type    end_type;
         typedef iterator_range<begin_type, end_type>    pair_type;
         typedef cons<pair_type, Stack>                  type;
 
-        static type call(Range& rng, Stack stack)
+        static type call(Sequence& seq, Stack stack)
         {
-            return type(pair_type(fusion::begin(rng), fusion::end(rng)), stack);
+            return type(pair_type(fusion::begin(seq), fusion::end(seq)), stack);
         }
     };
 
-    template <typename Range, typename Stack>
+    template <typename Sequence, typename Stack>
     struct segmented_begin_impl
-      : segmented_begin_impl_aux<Range, Stack>
+      : segmented_begin_impl_aux<Sequence, Stack>
     {};
 
 }}}
diff --git a/include/boost/fusion/sequence/intrinsic/detail/segmented_end.hpp b/include/boost/fusion/sequence/intrinsic/detail/segmented_end.hpp
index 5287a725..4a3d5bf7 100644
--- a/include/boost/fusion/sequence/intrinsic/detail/segmented_end.hpp
+++ b/include/boost/fusion/sequence/intrinsic/detail/segmented_end.hpp
@@ -13,24 +13,24 @@
 
 namespace boost { namespace fusion { namespace detail
 {
-    //auto segmented_end( rng )
+    //auto segmented_end( seq )
     //{
-    //    return make_segmented_iterator( segmented_end_impl( rng ) );
+    //    return make_segmented_iterator( segmented_end_impl( seq ) );
     //}
 
-    template<typename Range>
+    template <typename Sequence>
     struct segmented_end
     {
         typedef
             segmented_iterator<
-                typename segmented_end_impl<Range, fusion::nil>::type
+                typename segmented_end_impl<Sequence, fusion::nil>::type
             >
         type;
 
-        static type call(Range & rng)
+        static type call(Sequence & seq)
         {
             return type(
-                segmented_end_impl<Range, fusion::nil>::call(rng, fusion::nil()));
+                segmented_end_impl<Sequence, fusion::nil>::call(seq, fusion::nil()));
         }
     };
 
diff --git a/include/boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp b/include/boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp
index 1df8b4bd..149027bc 100644
--- a/include/boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp
+++ b/include/boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp
@@ -22,23 +22,23 @@ namespace boost { namespace fusion
 
 namespace boost { namespace fusion { namespace detail
 {
-    //auto segmented_end_impl( rng, stack )
+    //auto segmented_end_impl( seq, stack )
     //{
-    //    assert(is_segmented(rng));
-    //    auto it = end(segments(rng));
+    //    assert(is_segmented(seq));
+    //    auto it = end(segments(seq));
     //    return cons(iterator_range(it, it), stack);
     //}
 
-    template<typename Range, typename Stack>
+    template <typename Sequence, typename Stack>
     struct segmented_end_impl
     {
-        BOOST_MPL_ASSERT((traits::is_segmented<Range>));
+        BOOST_MPL_ASSERT((traits::is_segmented<Sequence>));
 
         typedef
             typename result_of::end<
                 typename remove_reference<
                     typename add_const<
-                        typename result_of::segments<Range>::type
+                        typename result_of::segments<Sequence>::type
                     >::type
                 >::type
             >::type
@@ -47,9 +47,9 @@ namespace boost { namespace fusion { namespace detail
         typedef iterator_range<end_type, end_type>  pair_type;
         typedef cons<pair_type, Stack>              type;
 
-        static type call(Range & rng, Stack stack)
+        static type call(Sequence & seq, Stack stack)
         {
-            end_type end = fusion::end(fusion::segments(rng));
+            end_type end = fusion::end(fusion::segments(seq));
             return type(pair_type(end, end), stack);
         }
     };
diff --git a/include/boost/fusion/sequence/intrinsic/detail/segmented_size.hpp b/include/boost/fusion/sequence/intrinsic/detail/segmented_size.hpp
index 3354b651..2af69735 100644
--- a/include/boost/fusion/sequence/intrinsic/detail/segmented_size.hpp
+++ b/include/boost/fusion/sequence/intrinsic/detail/segmented_size.hpp
@@ -28,14 +28,14 @@ namespace boost { namespace fusion { namespace detail
     ///////////////////////////////////////////////////////////////////////////
     template<typename Sequence, bool IsSegmented = traits::is_segmented<Sequence>::value>
     struct segmented_size_impl
-        : mpl::fold<
+      : mpl::fold<
             typename remove_reference<
                 typename add_const<
                     typename result_of::segments<Sequence>::type
                 >::type
-            >::type,
-            mpl::size_t<0>,
-            mpl::plus<mpl::_1, segmented_size<mpl::_2> >
+            >::type
+          , mpl::size_t<0>
+          , mpl::plus<mpl::_1, segmented_size<mpl::_2> >
         >::type
     {};
 
diff --git a/include/boost/fusion/support/detail/segmented_fold_until_impl.hpp b/include/boost/fusion/support/detail/segmented_fold_until_impl.hpp
index cdc5eb1e..38d68fc0 100644
--- a/include/boost/fusion/support/detail/segmented_fold_until_impl.hpp
+++ b/include/boost/fusion/support/detail/segmented_fold_until_impl.hpp
@@ -24,8 +24,8 @@
 #include <boost/fusion/support/is_segmented.hpp>
 #include <boost/fusion/sequence/intrinsic/segments.hpp>
 
-// fun(rng, state, context)
-//  rng: a non-segmented range
+// fun(seq, state, context)
+//  seq: a non-segmented range
 //  state: the state of the fold so far
 //  context: the path to the current range
 //
@@ -46,8 +46,8 @@ namespace boost { namespace fusion
         {
             typedef
                 iterator_range<
-                    Cur,
-                    typename result_of::end<
+                    Cur
+                  , typename result_of::end<
                         typename remove_reference<
                             typename add_const<
                                 typename result_of::deref<
@@ -118,31 +118,31 @@ namespace boost { namespace fusion
     namespace detail
     {
         template <
-            typename Begin,
-            typename End,
-            typename State,
-            typename Context,
-            typename Fun,
-            bool IsEmpty = result_of::empty<
+            typename Begin
+          , typename End
+          , typename State
+          , typename Context
+          , typename Fun
+          , bool IsEmpty = result_of::empty<
                 typename result_of::value_of<Begin>::type
             >::type::value>
         struct segmented_fold_until_iterate_skip_empty;
 
         template <
-            typename Begin,
-            typename End,
-            typename State,
-            typename Context,
-            typename Fun,
-            bool IsDone = result_of::equal_to<Begin, End>::type::value>
+            typename Begin
+          , typename End
+          , typename State
+          , typename Context
+          , typename Fun
+          , bool IsDone = result_of::equal_to<Begin, End>::type::value>
         struct segmented_fold_until_iterate;
 
         template <
-            typename Range,
-            typename State,
-            typename Context,
-            typename Fun,
-            bool IsSegmented = traits::is_segmented<Range>::type::value>
+            typename Sequence
+          , typename State
+          , typename Context
+          , typename Fun
+          , bool IsSegmented = traits::is_segmented<Sequence>::type::value>
         struct segmented_fold_until_impl;
 
         template <typename Segments, typename State, typename Context, typename Fun>
@@ -170,65 +170,65 @@ namespace boost { namespace fusion
         //  return segmented_iterator(push_context(cur, end, context));
         //}
         //
-        //auto segmented_fold_until_impl(rng, state, context, fun)
+        //auto segmented_fold_until_impl(seq, state, context, fun)
         //{
-        //  if (is_segmented(rng))
+        //  if (is_segmented(seq))
         //  {
-        //    segmented_fold_until_on_segments(segments(rng), state, context, fun);
+        //    segmented_fold_until_on_segments(segments(seq), state, context, fun);
         //  }
         //  else
         //  {
-        //    return fun(rng, state, context);
+        //    return fun(seq, state, context);
         //  }
         //}
 
         template <
-            typename Range,
-            typename State,
-            typename Context,
-            typename Fun,
-            bool IsSegmented>
+            typename Sequence
+          , typename State
+          , typename Context
+          , typename Fun
+          , bool IsSegmented>
         struct segmented_fold_until_impl
         {
             typedef
                 segmented_fold_until_on_segments<
                     typename remove_reference<
                         typename add_const<
-                            typename result_of::segments<Range>::type
+                            typename result_of::segments<Sequence>::type
                         >::type
-                    >::type,
-                    State,
-                    Context,
-                    Fun
+                    >::type
+                  , State
+                  , Context
+                  , Fun
                 >
             impl;
 
             typedef typename impl::type type;
 
-            static type call(Range& rng, State const& state, Context const& context, Fun const& fun)
+            static type call(Sequence& seq, State const& state, Context const& context, Fun const& fun)
             {
-                return impl::call(fusion::segments(rng), state, context, fun);
+                return impl::call(fusion::segments(seq), state, context, fun);
             }
         };
 
         template <
-            typename Range,
-            typename State,
-            typename Context,
-            typename Fun>
-        struct segmented_fold_until_impl<Range, State, Context, Fun, false>
+            typename Sequence
+          , typename State
+          , typename Context
+          , typename Fun>
+        struct segmented_fold_until_impl<Sequence, State, Context, Fun, false>
         {
             typedef
                 typename boost::result_of<Fun(
-                    Range&,
-                    typename add_reference<typename add_const<typename State::value_type>::type>::type,
-                    Context const&
+                    Sequence&
+                  , typename add_reference<typename add_const<typename State::value_type>::type>::type
+                  , Context const&
                 )>::type
             type;
             
-            static type call(Range& rng, State const& state, Context const& context, Fun const& fun)
+            static type call(Sequence& seq, State const& state, Context const& context, Fun const& fun)
             {
-                return fun(rng, state.value, context);
+                return fun(seq, state.value, context);
             }
         };
 
@@ -264,10 +264,10 @@ namespace boost { namespace fusion
                         typename add_const<
                             typename result_of::deref<Begin>::type
                         >::type
-                    >::type,
-                    State,
-                    next_context_type,
-                    Fun
+                    >::type
+                  , State
+                  , next_context_type
+                  , Fun
                 >
             fold_recurse_impl;
 
@@ -277,51 +277,51 @@ namespace boost { namespace fusion
 
             typedef
                 segmented_fold_until_iterate<
-                    typename result_of::next<Begin>::type,
-                    End,
-                    next_state_type,
-                    Context,
-                    Fun
+                    typename result_of::next<Begin>::type
+                  , End
+                  , next_state_type
+                  , Context
+                  , Fun
                 >
             next_iteration_impl;
 
             typedef
                 typename mpl::eval_if<
-                    typename next_state_type::continue_type,
-                    next_iteration_impl,
-                    mpl::identity<next_state_type>
+                    typename next_state_type::continue_type
+                  , next_iteration_impl
+                  , mpl::identity<next_state_type>
                 >::type
             type;
 
-            static type call(Begin const& beg, End const& end, State const& state,
-                             Context const& context, Fun const& fun)
+            static type call(Begin const& beg, End const& end, State const& state
+                           , Context const& context, Fun const& fun)
             {
                 return call(beg, end, state, context, fun, typename next_state_type::continue_type());
             }
 
-            static type call(Begin const& beg, End const& end, State const& state,
-                             Context const& context, Fun const& fun, mpl::true_) // continue
+            static type call(Begin const& beg, End const& end, State const& state
+                           , Context const& context, Fun const& fun, mpl::true_) // continue
             {
                 return next_iteration_impl::call(
-                    fusion::next(beg),
-                    end,
-                    fold_recurse_impl::call(
-                        *beg,
-                        state,
-                        push_context_impl::call(beg, end, context),
-                        fun),
-                    context,
-                    fun);
+                    fusion::next(beg)
+                  , end
+                  , fold_recurse_impl::call(
+                        *beg
+                      , state
+                      , push_context_impl::call(beg, end, context)
+                      , fun)
+                  , context
+                  , fun);
             }
 
-            static type call(Begin const& beg, End const& end, State const& state,
-                             Context const& context, Fun const& fun, mpl::false_) // break
+            static type call(Begin const& beg, End const& end, State const& state
+                           , Context const& context, Fun const& fun, mpl::false_) // break
             {
                 return fold_recurse_impl::call(
-                    *beg,
-                    state,
-                    push_context_impl::call(beg, end, context),
-                    fun);
+                    *beg
+                  , state
+                  , push_context_impl::call(beg, end, context)
+                  , fun);
             }
         };
 
@@ -330,18 +330,18 @@ namespace boost { namespace fusion
         {
             typedef
                 segmented_fold_until_iterate<
-                    typename result_of::next<Begin>::type,
-                    End,
-                    State,
-                    Context,
-                    Fun
+                    typename result_of::next<Begin>::type
+                  , End
+                  , State
+                  , Context
+                  , Fun
                 >
             impl;
             
             typedef typename impl::type type;
 
-            static type call(Begin const& beg, End const& end, State const& state,
-                             Context const& context, Fun const& fun)
+            static type call(Begin const& beg, End const& end, State const& state
+                           , Context const& context, Fun const& fun)
             {
                 return impl::call(fusion::next(beg), end, state, context, fun);
             }
@@ -356,8 +356,8 @@ namespace boost { namespace fusion
             
             typedef typename impl::type type;
 
-            static type call(Begin const& beg, End const& end, State const& state,
-                             Context const& context, Fun const& fun)
+            static type call(Begin const& beg, End const& end, State const& state
+                           , Context const& context, Fun const& fun)
             {
                 return impl::call(beg, end, state, context, fun);
             }
@@ -368,8 +368,8 @@ namespace boost { namespace fusion
         {
             typedef State type;
 
-            static type call(Begin const&, End const&, State const& state,
-                             Context const&, Fun const&)
+            static type call(Begin const&, End const&, State const& state
+                           , Context const&, Fun const&)
             {
                 return state;
             }
@@ -380,11 +380,11 @@ namespace boost { namespace fusion
         {
             typedef
                 segmented_fold_until_iterate<
-                    typename result_of::begin<Segments>::type,
-                    typename result_of::end<Segments>::type,
-                    State,
-                    Context,
-                    Fun
+                    typename result_of::begin<Segments>::type
+                  , typename result_of::end<Segments>::type
+                  , State
+                  , Context
+                  , Fun
                 >
             impl;
 
diff --git a/include/boost/fusion/support/segmented_fold_until.hpp b/include/boost/fusion/support/segmented_fold_until.hpp
index 670266ce..15f51707 100644
--- a/include/boost/fusion/support/segmented_fold_until.hpp
+++ b/include/boost/fusion/support/segmented_fold_until.hpp
@@ -7,6 +7,8 @@
 #if !defined(BOOST_FUSION_SEGMENTED_FOLD_UNTIL_HPP_INCLUDED)
 #define BOOST_FUSION_SEGMENTED_FOLD_UNTIL_HPP_INCLUDED
 
+#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>
@@ -16,45 +18,56 @@
 
 namespace boost { namespace fusion
 {
-    //auto segmented_fold_until(rng, state, fun)
+    //auto segmented_fold_until(seq, state, fun)
     //{
-    //  return first(segmented_fold_until_impl(rng, state, nil, fun));
+    //  return first(segmented_fold_until_impl(seq, state, nil, fun));
     //}
 
     namespace result_of
     {
-        template <typename Range, typename State, typename Fun>
+        template <typename Sequence, typename State, typename Fun>
         struct segmented_fold_until
         {
             typedef
                 detail::segmented_fold_until_impl<
-                    Range,
-                    result<State, continue_>,
-                    fusion::nil,
-                    Fun
+                    Sequence
+                  , result<State, continue_>
+                  , fusion::nil
+                  , Fun
                 >
-            impl;
+            filter;
 
             typedef
-                typename impl::type::value_type
+                typename filter::type::value_type
             type;
         };
     }
 
-    template <typename Range, typename State, typename Fun>
-    typename result_of::segmented_fold_until<Range, State, Fun>::type
-    segmented_fold_until(Range& rng, State const& state, Fun const& fun)
+    template <typename Sequence, typename State, typename Fun>
+    typename 
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::segmented_fold_until<Sequence, State, Fun>
+        >::type
+    segmented_fold_until(Sequence& seq, State const& state, Fun const& fun)
     {
-        typedef typename result_of::segmented_fold_until<Range, State, Fun>::impl impl;
-        return impl::call(rng, state, fusion::nil(), fun).value;
+        typedef
+            typename result_of::segmented_fold_until<Sequence, State, Fun>::filter
+        filter;
+        
+        return filter::call(seq, state, fusion::nil(), fun).value;
     }
 
-    template <typename Range, typename State, typename Fun>
-    typename result_of::segmented_fold_until<Range const, State, Fun>::type
-    segmented_fold_until(Range const& rng, State const& state, Fun const& fun)
+    template <typename Sequence, typename State, typename Fun>
+    typename result_of::segmented_fold_until<Sequence const, State, Fun>::type
+    segmented_fold_until(Sequence const& seq, State const& state, Fun const& fun)
     {
-        typedef typename result_of::segmented_fold_until<Range const, State, Fun>::impl impl;
-        return impl::call(rng, state, fusion::nil(), fun).value;
+        typedef
+            typename result_of::segmented_fold_until<Sequence const, State, Fun>::filter
+        filter;
+        
+        return filter::call(seq, state, fusion::nil(), fun).value;
     }
 }}
+
 #endif
diff --git a/include/boost/fusion/view/filter_view/detail/next_impl.hpp b/include/boost/fusion/view/filter_view/detail/next_impl.hpp
index a436bfc2..d575d3b3 100644
--- a/include/boost/fusion/view/filter_view/detail/next_impl.hpp
+++ b/include/boost/fusion/view/filter_view/detail/next_impl.hpp
@@ -65,7 +65,7 @@ namespace boost { namespace fusion
                 static type
                 call(Iterator const& i)
                 {
-                    return type(filter::call(i.first));
+                    return type(filter::iter_call(i.first));
                 }
             };
         };
diff --git a/include/boost/fusion/view/filter_view/filter_view_iterator.hpp b/include/boost/fusion/view/filter_view/filter_view_iterator.hpp
index 8ce63cbd..5da7bf34 100644
--- a/include/boost/fusion/view/filter_view/filter_view_iterator.hpp
+++ b/include/boost/fusion/view/filter_view/filter_view_iterator.hpp
@@ -55,7 +55,7 @@ namespace boost { namespace fusion
         typedef Pred pred_type;
 
         filter_iterator(First const& in_first)
-            : first(filter::call(first_converter::call(in_first))) {}
+            : first(filter::iter_call(first_converter::call(in_first))) {}
 
         first_type first;
 
diff --git a/include/boost/fusion/view/iterator_range/detail/is_segmented_impl.hpp b/include/boost/fusion/view/iterator_range/detail/is_segmented_impl.hpp
index 5ca20378..032225dc 100644
--- a/include/boost/fusion/view/iterator_range/detail/is_segmented_impl.hpp
+++ b/include/boost/fusion/view/iterator_range/detail/is_segmented_impl.hpp
@@ -53,9 +53,9 @@ namespace boost { namespace fusion
               : is_segmented_iterator<typename Sequence::begin_type>
             {
                 BOOST_MPL_ASSERT_RELATION(
-                    is_segmented_iterator<typename Sequence::begin_type>::value,
-                    ==,
-                    is_segmented_iterator<typename Sequence::end_type>::value);
+                    is_segmented_iterator<typename Sequence::begin_type>::value
+                  , ==
+                  , is_segmented_iterator<typename Sequence::end_type>::value);
             };
         };
     }
diff --git a/include/boost/fusion/view/iterator_range/detail/segmented_iterator_range.hpp b/include/boost/fusion/view/iterator_range/detail/segmented_iterator_range.hpp
index df5f7a93..e7765b2f 100644
--- a/include/boost/fusion/view/iterator_range/detail/segmented_iterator_range.hpp
+++ b/include/boost/fusion/view/iterator_range/detail/segmented_iterator_range.hpp
@@ -82,16 +82,16 @@ namespace boost { namespace fusion { namespace detail
                             >::type
                         >::type
                     >::type
-                >::type,
-                typename Stack::cdr_type::car_type::end_type
+                >::type
+              , typename Stack::cdr_type::car_type::end_type
             >));
 
         typedef
             iterator_range<
                 typename result_of::next<
                     typename Stack::cdr_type::car_type::begin_type
-                >::type,
-                typename result_of::end<
+                >::type
+              , typename result_of::end<
                     typename remove_reference<
                         typename add_const<
                             typename result_of::segments<
@@ -116,8 +116,8 @@ namespace boost { namespace fusion { namespace detail
         typedef
             segment_sequence<
                 typename result_of::push_front<
-                    rest_type const,
-                    typename recurse::type 
+                    rest_type const
+                  , typename recurse::type 
                 >::type
             >
         type;
@@ -130,8 +130,8 @@ namespace boost { namespace fusion { namespace detail
             //    make_segment_sequence_front(cdr(stack_begin))));
             return type(
                 fusion::push_front(
-                    rest_type(fusion::next(stack.cdr.car.first), fusion::end(fusion::segments(*stack.car.first))),
-                    recurse::call(stack.cdr)));
+                    rest_type(fusion::next(stack.cdr.car.first), fusion::end(fusion::segments(*stack.car.first)))
+                  , recurse::call(stack.cdr)));
         }
     };
 
@@ -149,14 +149,14 @@ namespace boost { namespace fusion { namespace detail
                             >::type
                         >::type
                     >::type
-                >::type,
-                typename Stack::cdr_type::car_type::end_type
+                >::type
+              , typename Stack::cdr_type::car_type::end_type
             >));
 
         typedef
             iterator_range<
-                typename Stack::cdr_type::car_type::begin_type,
-                typename result_of::end<
+                typename Stack::cdr_type::car_type::begin_type
+              , typename result_of::end<
                     typename remove_reference<
                         typename add_const<
                             typename result_of::deref<
@@ -226,8 +226,8 @@ namespace boost { namespace fusion { namespace detail
                             >::type
                         >::type
                     >::type
-                >::type,
-                typename Stack::cdr_type::car_type::end_type
+                >::type
+              , typename Stack::cdr_type::car_type::end_type
             >));
 
         typedef
@@ -246,8 +246,8 @@ namespace boost { namespace fusion { namespace detail
                             >::type
                         >::type
                     >::type
-                >::type,
-                typename Stack::cdr_type::car_type::begin_type
+                >::type
+              , typename Stack::cdr_type::car_type::begin_type
             >
         rest_type;
 
@@ -258,8 +258,8 @@ namespace boost { namespace fusion { namespace detail
         typedef
             segment_sequence<
                 typename result_of::push_back<
-                    rest_type const,
-                    typename recurse::type 
+                    rest_type const
+                  , typename recurse::type 
                 >::type
             >
         type;
@@ -272,8 +272,8 @@ namespace boost { namespace fusion { namespace detail
             //      make_segment_sequence_back(cdr(stack_end))));
             return type(
                 fusion::push_back(
-                    rest_type(fusion::begin(fusion::segments(*stack.car.first)), stack.cdr.car.first),
-                    recurse::call(stack.cdr)));
+                    rest_type(fusion::begin(fusion::segments(*stack.car.first)), stack.cdr.car.first)
+                  , recurse::call(stack.cdr)));
         }
     };
 
@@ -291,8 +291,8 @@ namespace boost { namespace fusion { namespace detail
                             >::type
                         >::type
                     >::type
-                >::type,
-                typename Stack::cdr_type::car_type::end_type
+                >::type
+              , typename Stack::cdr_type::car_type::end_type
             >));
 
         typedef
@@ -305,8 +305,8 @@ namespace boost { namespace fusion { namespace detail
                             >::type
                         >::type
                     >::type
-                >::type,
-                typename Stack::cdr_type::car_type::begin_type
+                >::type
+              , typename Stack::cdr_type::car_type::begin_type
             >
         type;
 
@@ -362,19 +362,19 @@ namespace boost { namespace fusion { namespace detail
     //}
 
     template <
-        typename StackBegin,
-        typename StackEnd,
-        int StackBeginSize = StackBegin::size::value,
-        int StackEndSize   = StackEnd::size::value>
+        typename StackBegin
+      , typename StackEnd
+      , int StackBeginSize = StackBegin::size::value
+      , int StackEndSize   = StackEnd::size::value>
     struct make_segmented_range_reduce;
 
     template <
-        typename StackBegin,
-        typename StackEnd,
-        bool SameSegment = 
+        typename StackBegin
+      , typename StackEnd
+      , bool SameSegment = 
             result_of::equal_to<
-                typename StackBegin::car_type::begin_type,
-                typename StackEnd::car_type::begin_type
+                typename StackBegin::car_type::begin_type
+              , typename StackEnd::car_type::begin_type
             >::type::value>
     struct make_segmented_range_reduce2
     {
@@ -382,8 +382,8 @@ namespace boost { namespace fusion { namespace detail
             iterator_range<
                 typename result_of::next<
                     typename StackBegin::car_type::begin_type
-                >::type,
-                typename StackEnd::car_type::begin_type
+                >::type
+              , typename StackEnd::car_type::begin_type
             >
         rest_type;
 
@@ -391,10 +391,10 @@ namespace boost { namespace fusion { namespace detail
             segment_sequence<
                 typename result_of::push_back<
                     typename result_of::push_front<
-                        rest_type const,
-                        typename make_segment_sequence_front<StackBegin>::type
-                    >::type const,
-                    typename make_segment_sequence_back<StackEnd>::type
+                        rest_type const
+                      , typename make_segment_sequence_front<StackBegin>::type
+                    >::type const
+                  , typename make_segment_sequence_back<StackEnd>::type
                 >::type
             >
         type;
@@ -412,9 +412,9 @@ namespace boost { namespace fusion { namespace detail
             return type(
                 fusion::push_back(
                     fusion::push_front(
-                        rest_type(fusion::next(stack_begin.car.first), stack_end.car.first),
-                        make_segment_sequence_front<StackBegin>::call(stack_begin)),
-                    make_segment_sequence_back<StackEnd>::call(stack_end)));
+                        rest_type(fusion::next(stack_begin.car.first), stack_end.car.first)
+                      , make_segment_sequence_front<StackBegin>::call(stack_begin))
+                  , make_segment_sequence_back<StackEnd>::call(stack_end)));
         }
     };
 
@@ -423,8 +423,8 @@ namespace boost { namespace fusion { namespace detail
     {
         typedef
             make_segmented_range_reduce<
-                typename StackBegin::cdr_type,
-                typename StackEnd::cdr_type
+                typename StackBegin::cdr_type
+              , typename StackEnd::cdr_type
             >
         impl;
 
@@ -448,8 +448,8 @@ namespace boost { namespace fusion { namespace detail
     {
         typedef
             iterator_range<
-                typename StackBegin::car_type::begin_type,
-                typename StackEnd::car_type::begin_type
+                typename StackBegin::car_type::begin_type
+              , typename StackEnd::car_type::begin_type
             >
         range_type;
 
@@ -483,8 +483,8 @@ namespace boost { namespace fusion { namespace detail
 
         typedef
             make_segmented_range_reduce<
-                typename reverse_begin_cons::type,
-                typename reverse_end_cons::type
+                typename reverse_begin_cons::type
+              , typename reverse_end_cons::type
             >
         impl;
 
@@ -493,8 +493,8 @@ namespace boost { namespace fusion { namespace detail
         static type call(Begin const & begin, End const & end)
         {
             return impl::call(
-                reverse_begin_cons::call(begin.context),
-                reverse_end_cons::call(end.context));
+                reverse_begin_cons::call(begin.context)
+              , reverse_end_cons::call(end.context));
         }
     };
 
diff --git a/include/boost/fusion/view/iterator_range/detail/segments_impl.hpp b/include/boost/fusion/view/iterator_range/detail/segments_impl.hpp
index 5d114615..ede49683 100644
--- a/include/boost/fusion/view/iterator_range/detail/segments_impl.hpp
+++ b/include/boost/fusion/view/iterator_range/detail/segments_impl.hpp
@@ -29,8 +29,8 @@ namespace boost { namespace fusion
             {
                 typedef
                     detail::make_segmented_range<
-                        typename Sequence::begin_type,
-                        typename Sequence::end_type
+                        typename Sequence::begin_type
+                      , typename Sequence::end_type
                     >
                 impl;
 
diff --git a/test/algorithm/segmented_find.cpp b/test/algorithm/segmented_find.cpp
index 4c4c31a5..3db7b725 100644
--- a/test/algorithm/segmented_find.cpp
+++ b/test/algorithm/segmented_find.cpp
@@ -7,7 +7,7 @@
 ==============================================================================*/
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
-#include <boost/fusion/algorithm/query/ext_/find_s.hpp>
+#include <boost/fusion/algorithm/query/find.hpp>
 #include <boost/fusion/container/generation/make_vector.hpp>
 #include "../sequence/tree.hpp"
 
@@ -19,21 +19,21 @@ process_tree(Tree const &tree)
 {
     using namespace boost;
 
-    typedef typename boost::fusion::result_of::find_s<Tree const, short>::type short_iter;
-    typedef typename boost::fusion::result_of::find_s<Tree const, float>::type float_iter;
-    typedef typename boost::fusion::result_of::find_s<Tree const, not_there>::type not_there_iter;
+    typedef typename boost::fusion::result_of::find<Tree const, short>::type short_iter;
+    typedef typename boost::fusion::result_of::find<Tree const, float>::type float_iter;
+    typedef typename boost::fusion::result_of::find<Tree const, not_there>::type not_there_iter;
 
     // find_if_s of a segmented data structure returns generic
     // segmented iterators
-    short_iter si = fusion::find_s<short>(tree);
-    float_iter fi = fusion::find_s<float>(tree);
+    short_iter si = fusion::find<short>(tree);
+    float_iter fi = fusion::find<float>(tree);
 
     // they behave like ordinary Fusion iterators ...
     BOOST_TEST((*si == short('d')));
     BOOST_TEST((*fi == float(1)));
 
     // Searching for something that's not there should return the end iterator.
-    not_there_iter nti = fusion::find_s<not_there>(tree);
+    not_there_iter nti = fusion::find<not_there>(tree);
     BOOST_TEST((nti == fusion::end(tree)));
 }
 
diff --git a/test/algorithm/segmented_find_if.cpp b/test/algorithm/segmented_find_if.cpp
index 14a2af7e..5ee71d10 100644
--- a/test/algorithm/segmented_find_if.cpp
+++ b/test/algorithm/segmented_find_if.cpp
@@ -7,7 +7,7 @@
 ==============================================================================*/
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
-#include <boost/fusion/algorithm/query/ext_/find_if_s.hpp>
+#include <boost/fusion/algorithm/query/find_if.hpp>
 #include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/mpl/placeholders.hpp>
 #include <boost/type_traits/is_same.hpp>
@@ -22,21 +22,21 @@ process_tree(Tree const &tree)
     using namespace boost;
     using mpl::_;
 
-    typedef typename boost::fusion::result_of::find_if_s<Tree const, is_same<_,short> >::type short_iter;
-    typedef typename boost::fusion::result_of::find_if_s<Tree const, is_same<_,float> >::type float_iter;
-    typedef typename boost::fusion::result_of::find_if_s<Tree const, is_same<_,not_there> >::type not_there_iter;
+    typedef typename boost::fusion::result_of::find_if<Tree const, is_same<_,short> >::type short_iter;
+    typedef typename boost::fusion::result_of::find_if<Tree const, is_same<_,float> >::type float_iter;
+    typedef typename boost::fusion::result_of::find_if<Tree const, is_same<_,not_there> >::type not_there_iter;
 
-    // find_if_s of a segmented data structure returns generic
+    // find_if of a segmented data structure returns generic
     // segmented iterators
-    short_iter si = fusion::find_if_s<is_same<_,short> >(tree);
-    float_iter fi = fusion::find_if_s<is_same<_,float> >(tree);
+    short_iter si = fusion::find_if<is_same<_,short> >(tree);
+    float_iter fi = fusion::find_if<is_same<_,float> >(tree);
 
     // they behave like ordinary Fusion iterators ...
     BOOST_TEST((*si == short('d')));
     BOOST_TEST((*fi == float(1)));
 
     // Searching for something that's not there should return the end iterator.
-    not_there_iter nti = fusion::find_if_s<is_same<_,not_there> >(tree);
+    not_there_iter nti = fusion::find_if<is_same<_,not_there> >(tree);
     BOOST_TEST((nti == fusion::end(tree)));
 }
 
diff --git a/test/sequence/segmented_iterator_range.cpp b/test/sequence/segmented_iterator_range.cpp
index 4f75d592..55d9e33b 100644
--- a/test/sequence/segmented_iterator_range.cpp
+++ b/test/sequence/segmented_iterator_range.cpp
@@ -8,7 +8,7 @@
 #include <sstream>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/algorithm/iteration/ext_/for_each_s.hpp>
-#include <boost/fusion/algorithm/query/ext_/find_if_s.hpp>
+#include <boost/fusion/algorithm/query/find_if.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/container/generation/make_vector.hpp>
 #include <boost/fusion/view/iterator_range/iterator_range.hpp>
@@ -43,16 +43,16 @@ process_tree(Tree const &tree)
     using namespace fusion;
     using mpl::_;
 
-    typedef typename boost::fusion::result_of::find_if_s<Tree const, is_same<_,short> >::type short_iter;
-    typedef typename boost::fusion::result_of::find_if_s<Tree const, is_same<_,float> >::type float_iter;
+    typedef typename boost::fusion::result_of::find_if<Tree const, is_same<_,short> >::type short_iter;
+    typedef typename boost::fusion::result_of::find_if<Tree const, is_same<_,float> >::type float_iter;
 
     typedef iterator_range<short_iter, float_iter> slice_t;
     BOOST_STATIC_ASSERT(traits::is_segmented<slice_t>::value);
 
-    // find_if_s of a segmented data structure returns generic
+    // find_if of a segmented data structure returns generic
     // segmented iterators
-    short_iter si = find_if_s<is_same<_,short> >(tree);
-    float_iter fi = find_if_s<is_same<_,float> >(tree);
+    short_iter si = find_if<is_same<_,short> >(tree);
+    float_iter fi = find_if<is_same<_,float> >(tree);
 
     // If you put them in an iterator range, the range
     // is automatically a segmented data structure.