Boost.Range algorithms are now in the boost::range namespace and brought into boost by the appropriate using statement. This allows better interoperation with Boost.Algorithm since errors only occur when the use calls similarly named ambiguous functions. In this event the user can disambiguate by using algorithm::xxx() or range::xxx(). This iteration also updates the concept assert code in the range algorithms.

[SVN r61023]

include/boost/range/algorithm/adjacent_find.hpp

@@ -19,101 +19,107 @@
 
 namespace boost
 {
-    /// \brief template function adjacent_find
+    namespace range
-    ///
-    /// range-based version of the adjacent_find std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template< typename ForwardRange >
-    inline typename range_iterator<ForwardRange>::type
-    adjacent_find(ForwardRange & rng)
     {
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        return std::adjacent_find(boost::begin(rng),boost::end(rng));
-    }
 
-    /// \overload
+/// \brief template function adjacent_find
-    template< typename ForwardRange >
+///
-    inline typename range_iterator<const ForwardRange>::type
+/// range-based version of the adjacent_find std algorithm
-    adjacent_find(const ForwardRange& rng)
+///
-    {
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-        return std::adjacent_find(boost::begin(rng),boost::end(rng));
+template< typename ForwardRange >
-    }
+inline typename range_iterator<ForwardRange>::type
+adjacent_find(ForwardRange & rng)
+{
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    return std::adjacent_find(boost::begin(rng),boost::end(rng));
+}
 
-    /// \overload
+/// \overload
-    template< typename ForwardRange, typename BinaryPredicate >
+template< typename ForwardRange >
-    inline typename range_iterator<ForwardRange>::type
+inline typename range_iterator<const ForwardRange>::type
-    adjacent_find(ForwardRange & rng, BinaryPredicate pred)
+adjacent_find(const ForwardRange& rng)
-    {
+{
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+    return std::adjacent_find(boost::begin(rng),boost::end(rng));
-            typename range_value<ForwardRange>::type,
+}
-            typename range_value<ForwardRange>::type>));
-        return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
-    }
 
-    /// \overload
+/// \overload
-    template< typename ForwardRange, typename BinaryPredicate >
+template< typename ForwardRange, typename BinaryPredicate >
-    inline typename range_iterator<const ForwardRange>::type
+inline typename range_iterator<ForwardRange>::type
-    adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
+adjacent_find(ForwardRange & rng, BinaryPredicate pred)
-    {
+{
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+    BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
-            typename range_value<const ForwardRange>::type,
+        typename range_value<ForwardRange>::type,
-            typename range_value<const ForwardRange>::type>));
+        typename range_value<ForwardRange>::type>));
-        return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
+    return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
-    }
+}
+
+/// \overload
+template< typename ForwardRange, typename BinaryPredicate >
+inline typename range_iterator<const ForwardRange>::type
+adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+        typename range_value<const ForwardRange>::type,
+        typename range_value<const ForwardRange>::type>));
+    return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
+}
 
 //  range_return overloads
 
-    /// \overload
+/// \overload
-    template< range_return_value re, typename ForwardRange >
+template< range_return_value re, typename ForwardRange >
-    inline typename range_return<ForwardRange,re>::type
+inline typename range_return<ForwardRange,re>::type
-    adjacent_find(ForwardRange & rng)
+adjacent_find(ForwardRange & rng)
-    {
+{
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        return range_return<ForwardRange,re>::
+    return range_return<ForwardRange,re>::
-            pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
+        pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
-                 rng);
+             rng);
-    }
-
-    /// \overload
-    template< range_return_value re, typename ForwardRange >
-    inline typename range_return<const ForwardRange,re>::type
-    adjacent_find(const ForwardRange& rng)
-    {
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        return range_return<const ForwardRange,re>::
-            pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
-                 rng);
-    }
-
-    /// \overload
-    template< range_return_value re, typename ForwardRange, typename BinaryPredicate >
-    inline typename range_return<ForwardRange,re>::type
-    adjacent_find(ForwardRange& rng, BinaryPredicate pred)
-    {
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
-            typename range_value<ForwardRange>::type,
-            typename range_value<ForwardRange>::type>));
-        return range_return<ForwardRange,re>::
-            pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
-                 rng);
-    }
-
-    /// \overload
-    template< range_return_value re, typename ForwardRange, typename BinaryPredicate >
-    inline typename range_return<const ForwardRange,re>::type
-    adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
-    {
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        return range_return<const ForwardRange,re>::
-            pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
-                 rng);
-    }
 }
 
+/// \overload
+template< range_return_value re, typename ForwardRange >
+inline typename range_return<const ForwardRange,re>::type
+adjacent_find(const ForwardRange& rng)
+{
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    return range_return<const ForwardRange,re>::
+        pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
+             rng);
+}
+
+/// \overload
+template< range_return_value re, typename ForwardRange, typename BinaryPredicate >
+inline typename range_return<ForwardRange,re>::type
+adjacent_find(ForwardRange& rng, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+        typename range_value<ForwardRange>::type,
+        typename range_value<ForwardRange>::type>));
+    return range_return<ForwardRange,re>::
+        pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
+             rng);
+}
+
+/// \overload
+template< range_return_value re, typename ForwardRange, typename BinaryPredicate >
+inline typename range_return<const ForwardRange,re>::type
+adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    return range_return<const ForwardRange,re>::
+        pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
+             rng);
+}
+
+    } // namespace range
+    using range::adjacent_find;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/binary_search.hpp

@@ -17,27 +17,33 @@
 
 namespace boost
 {
-    /// \brief template function binary_search
+    namespace range
-    ///
-    /// range-based version of the binary_search std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class ForwardRange, class Value>
-    inline bool binary_search(const ForwardRange& rng, const Value& val)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return std::binary_search(boost::begin(rng), boost::end(rng), val);
-    }
 
-    /// \overload
+/// \brief template function binary_search
-    template<class ForwardRange, class Value, class BinaryPredicate>
+///
-    inline bool binary_search(const ForwardRange& rng, const Value& val,
+/// range-based version of the binary_search std algorithm
-                              BinaryPredicate pred)
+///
-    {
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-        return std::binary_search(boost::begin(rng), boost::end(rng), val, pred);
+template<class ForwardRange, class Value>
-    }
+inline bool binary_search(const ForwardRange& rng, const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::binary_search(boost::begin(rng), boost::end(rng), val);
 }
 
+/// \overload
+template<class ForwardRange, class Value, class BinaryPredicate>
+inline bool binary_search(const ForwardRange& rng, const Value& val,
+                          BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::binary_search(boost::begin(rng), boost::end(rng), val, pred);
+}
+
+    } // namespace range
+    using range::binary_search;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/copy.hpp

@@ -18,18 +18,24 @@
 
 namespace boost
 {
-    /// \brief template function copy
+    namespace range
-    ///
-    /// range-based version of the copy std algorithm
-    ///
-    /// \pre SinglePassRange is a model of the SinglePassRangeConcept
-    /// \pre OutputIterator is a model of the OutputIteratorConcept
-    template< class SinglePassRange, class OutputIterator >
-    inline OutputIterator copy(const SinglePassRange& rng, OutputIterator out)
     {
-        //BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+
-        return std::copy(boost::begin(rng),boost::end(rng),out);
+/// \brief template function copy
-    }
+///
+/// range-based version of the copy std algorithm
+///
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
+/// \pre OutputIterator is a model of the OutputIteratorConcept
+template< class SinglePassRange, class OutputIterator >
+inline OutputIterator copy(const SinglePassRange& rng, OutputIterator out)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+    return std::copy(boost::begin(rng),boost::end(rng),out);
 }
 
+    } // namespace range
+    using range::copy;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/copy_backward.hpp

@@ -17,21 +17,27 @@
 
 namespace boost
 {
-    /// \brief template function copy_backward
+    namespace range
-    ///
-    /// range-based version of the copy_backwards std algorithm
-    ///
-    /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
-    /// \pre BidirectionalTraversalWriteableIterator is a model of the BidirectionalIteratorConcept
-    /// \pre BidirectionalTraversalWriteableIterator is a model of the WriteableIteratorConcept
-    template< class BidirectionalRange, class BidirectionalTraversalWriteableIterator >
-    inline BidirectionalTraversalWriteableIterator
-    copy_backward(const BidirectionalRange& rng,
-                  BidirectionalTraversalWriteableIterator out)
     {
-        boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+
-        return std::copy_backward(boost::begin(rng), boost::end(rng), out);
+/// \brief template function copy_backward
-    }
+///
+/// range-based version of the copy_backwards std algorithm
+///
+/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
+/// \pre BidirectionalTraversalWriteableIterator is a model of the BidirectionalIteratorConcept
+/// \pre BidirectionalTraversalWriteableIterator is a model of the WriteableIteratorConcept
+template< class BidirectionalRange, class BidirectionalTraversalWriteableIterator >
+inline BidirectionalTraversalWriteableIterator
+copy_backward(const BidirectionalRange& rng,
+              BidirectionalTraversalWriteableIterator out)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    return std::copy_backward(boost::begin(rng), boost::end(rng), out);
 }
 
+    } // namespace range
+    using range::copy_backward;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/count.hpp

@@ -18,27 +18,33 @@
 
 namespace boost
 {
-    /// \brief template function count
+    namespace range
-    ///
-    /// range-based version of the count std algorithm
-    ///
-    /// \pre SinglePassRange is a model of the SinglePassRangeConcept
-    template< class SinglePassRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type
-    count(SinglePassRange& rng, const Value& val)
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
-        return std::count(boost::begin(rng), boost::end(rng), val);
-    }
 
-    /// \overload
+/// \brief template function count
-    template< class SinglePassRange, class Value >
+///
-    inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange const>::type
+/// range-based version of the count std algorithm
-    count(const SinglePassRange& rng, const Value& val)
+///
-    {
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+template< class SinglePassRange, class Value >
-        return std::count(boost::begin(rng), boost::end(rng), val);
+inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type
-    }
+count(SinglePassRange& rng, const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+    return std::count(boost::begin(rng), boost::end(rng), val);
 }
 
+/// \overload
+template< class SinglePassRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange const>::type
+count(const SinglePassRange& rng, const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return std::count(boost::begin(rng), boost::end(rng), val);
+}
+
+    } // namespace range
+    using range::count;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/count_if.hpp

@@ -18,28 +18,34 @@
 
 namespace boost
 {
-    /// \brief template function count_if
+    namespace range
-    ///
-    /// range-based version of the count_if std algorithm
-    ///
-    /// \pre SinglePassRange is a model of the SinglePassRangeConcept
-    /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
-    template< class SinglePassRange, class UnaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME boost::range_difference<SinglePassRange>::type
-    count_if(SinglePassRange& rng, UnaryPredicate pred)
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
-        return std::count_if(boost::begin(rng), boost::end(rng), pred);
-    }
 
-    /// \overload
+/// \brief template function count_if
-    template< class SinglePassRange, class UnaryPredicate >
+///
-    inline BOOST_DEDUCED_TYPENAME boost::range_difference<const SinglePassRange>::type
+/// range-based version of the count_if std algorithm
-    count_if(const SinglePassRange& rng, UnaryPredicate pred)
+///
-    {
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
-        return std::count_if(boost::begin(rng), boost::end(rng), pred);
+template< class SinglePassRange, class UnaryPredicate >
-    }
+inline BOOST_DEDUCED_TYPENAME boost::range_difference<SinglePassRange>::type
+count_if(SinglePassRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+    return std::count_if(boost::begin(rng), boost::end(rng), pred);
 }
 
+/// \overload
+template< class SinglePassRange, class UnaryPredicate >
+inline BOOST_DEDUCED_TYPENAME boost::range_difference<const SinglePassRange>::type
+count_if(const SinglePassRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return std::count_if(boost::begin(rng), boost::end(rng), pred);
+}
+
+    } // namespace range
+    using range::count_if;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/equal.hpp

@@ -143,40 +143,46 @@ namespace boost
 
             return equal_impl(first1, last1, first2, last2, pred, tag1, tag2);
         }
- 
-    }
 
-    /// \brief template function equal
+    } // namespace range_detail
-    ///
+
-    /// range-based version of the equal std algorithm
+    namespace range
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template< class SinglePassRange1, class SinglePassRange2 >
-    inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
 
-        return range_detail::equal(
+        /// \brief template function equal
-            boost::begin(rng1), boost::end(rng1),
+        ///
-            boost::begin(rng2), boost::end(rng2) );
+        /// range-based version of the equal std algorithm
-    }
+        ///
+        /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+        /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+        /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+        template< class SinglePassRange1, class SinglePassRange2 >
+        inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
+        {
+            BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+            BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
 
-    /// \overload
+            return ::boost::range_detail::equal(
-    template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+                ::boost::begin(rng1), ::boost::end(rng1),
-    inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
+                ::boost::begin(rng2), ::boost::end(rng2) );
-                       BinaryPredicate pred )
+        }
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
 
-        return range_detail::equal(
+        /// \overload
-            boost::begin(rng1), boost::end(rng1),
+        template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
-            boost::begin(rng2), boost::end(rng2),
+        inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
-            pred);
+                           BinaryPredicate pred )
-    }
+        {
-}
+            BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+            BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+
+            return ::boost::range_detail::equal(
+                ::boost::begin(rng1), ::boost::end(rng1),
+                ::boost::begin(rng2), ::boost::end(rng2),
+                pred);
+        }
+
+    } // namespace range
+    using range::equal;
+} // namespace boost
 
 #endif // include guard

include/boost/range/algorithm/equal_range.hpp

@@ -17,58 +17,64 @@
 
 namespace boost
 {
-    /// \brief template function equal_range
+    namespace range
-    ///
-    /// range-based version of the equal_range std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    /// \pre SortPredicate is a model of the BinaryPredicateConcept
-    template<class ForwardRange, class Value>
-    inline std::pair<
-            BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type,
-            BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
-           >
-    equal_range(ForwardRange& rng, const Value& val)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return std::equal_range(boost::begin(rng), boost::end(rng), val);
-    }
 
-    /// \overload
+/// \brief template function equal_range
-    template<class ForwardRange, class Value>
+///
-    inline std::pair<
+/// range-based version of the equal_range std algorithm
-            BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
+///
-            BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-           >
+/// \pre SortPredicate is a model of the BinaryPredicateConcept
-    equal_range(const ForwardRange& rng, const Value& val)
+template<class ForwardRange, class Value>
-    {
+inline std::pair<
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+        BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type,
-		return std::equal_range(boost::begin(rng), boost::end(rng), val);
+        BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
-    }
+       >
-
+equal_range(ForwardRange& rng, const Value& val)
-    /// \overload
+{
-    template<class ForwardRange, class Value, class SortPredicate>
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    inline std::pair<
+    return std::equal_range(boost::begin(rng), boost::end(rng), val);
-            BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type,
-            BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
-           >
-    equal_range(ForwardRange& rng, const Value& val, SortPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
-    }
-
-    /// \overload
-    template<class ForwardRange, class Value, class SortPredicate>
-    inline std::pair<
-            BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
-            BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
-           >
-    equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
-    }
 }
 
+/// \overload
+template<class ForwardRange, class Value>
+inline std::pair<
+        BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
+        BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
+       >
+equal_range(const ForwardRange& rng, const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::equal_range(boost::begin(rng), boost::end(rng), val);
+}
+
+/// \overload
+template<class ForwardRange, class Value, class SortPredicate>
+inline std::pair<
+        BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type,
+        BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
+       >
+equal_range(ForwardRange& rng, const Value& val, SortPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
+}
+
+/// \overload
+template<class ForwardRange, class Value, class SortPredicate>
+inline std::pair<
+        BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
+        BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
+       >
+equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
+}
+
+    } // namespace range
+    using range::equal_range;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/fill.hpp

@@ -17,18 +17,24 @@
 
 namespace boost
 {
-    /// \brief template function fill
+    namespace range
-    ///
-    /// range-based version of the fill std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    template< class ForwardRange, class Value >
-    inline ForwardRange& fill(ForwardRange& rng, const Value& val)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
-        std::fill(boost::begin(rng), boost::end(rng), val);
+/// \brief template function fill
-        return rng;
+///
-    }
+/// range-based version of the fill std algorithm
+///
+/// \pre ForwardRange is a model of the ForwardRangeConcept
+template< class ForwardRange, class Value >
+inline ForwardRange& fill(ForwardRange& rng, const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    std::fill(boost::begin(rng), boost::end(rng), val);
+    return rng;
+}
+
+    } // namespace range
+    using range::fill;
 }
 
 #endif // include guard

include/boost/range/algorithm/fill_n.hpp

@@ -18,19 +18,25 @@
 
 namespace boost
 {
-    /// \brief template function fill_n
+    namespace range
-    ///
-    /// range-based version of the fill_n std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    template< class ForwardRange, class Size, class Value >
-    inline ForwardRange& fill_n(ForwardRange& rng, Size n, const Value& val)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
-        BOOST_ASSERT( static_cast<Size>(std::distance(boost::begin(rng), boost::end(rng))) >= n );
+/// \brief template function fill_n
-        std::fill_n(boost::begin(rng), n, val);
+///
-        return rng;
+/// range-based version of the fill_n std algorithm
-    }
+///
+/// \pre ForwardRange is a model of the ForwardRangeConcept
+template< class ForwardRange, class Size, class Value >
+inline ForwardRange& fill_n(ForwardRange& rng, Size n, const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    BOOST_ASSERT( static_cast<Size>(std::distance(boost::begin(rng), boost::end(rng))) >= n );
+    std::fill_n(boost::begin(rng), n, val);
+    return rng;
 }
 
+    } // namespace range
+    using range::fill_n;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/find.hpp

@@ -18,49 +18,55 @@
 
 namespace boost
 {
-    /// \brief template function find
+    namespace range
-    ///
-    /// range-based version of the find std algorithm
-    ///
-    /// \pre SinglePassRange is a model of the SinglePassRangeConcept
-    template< class SinglePassRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
-    find( SinglePassRange& rng, const Value& val )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+
-        return std::find(boost::begin(rng), boost::end(rng), val);
+/// \brief template function find
-    }
+///
-    /// \overload
+/// range-based version of the find std algorithm
-    template< class SinglePassRange, class Value >
+///
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
-    find( const SinglePassRange& rng, const Value& val )
+template< class SinglePassRange, class Value >
-    {
+inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+find( SinglePassRange& rng, const Value& val )
-        return std::find(boost::begin(rng), boost::end(rng), val);
+{
-    }
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+    return std::find(boost::begin(rng), boost::end(rng), val);
+}
+/// \overload
+template< class SinglePassRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
+find( const SinglePassRange& rng, const Value& val )
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return std::find(boost::begin(rng), boost::end(rng), val);
+}
 
 // range_return overloads
 
-    /// \overload
+/// \overload
-    template< range_return_value re, class SinglePassRange, class Value >
+template< range_return_value re, class SinglePassRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
-    find( SinglePassRange& rng, const Value& val )
+find( SinglePassRange& rng, const Value& val )
-    {
+{
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
-        return range_return<SinglePassRange,re>::
+    return range_return<SinglePassRange,re>::
-            pack(std::find(boost::begin(rng), boost::end(rng), val),
+        pack(std::find(boost::begin(rng), boost::end(rng), val),
-                 rng);
+             rng);
-    }
+}
-    /// \overload
+/// \overload
-    template< range_return_value re, class SinglePassRange, class Value >
+template< range_return_value re, class SinglePassRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
-    find( const SinglePassRange& rng, const Value& val )
+find( const SinglePassRange& rng, const Value& val )
-    {
+{
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
-        return range_return<const SinglePassRange,re>::
+    return range_return<const SinglePassRange,re>::
-            pack(std::find(boost::begin(rng), boost::end(rng), val),
+        pack(std::find(boost::begin(rng), boost::end(rng), val),
-                 rng);
+             rng);
-    }
+}
+
+    } // namespace range
+    using range::find;
 }
 
 #endif // include guard

include/boost/range/algorithm/find_end.hpp

@@ -18,119 +18,125 @@
 
 namespace boost
 {
-    /// \brief template function find_end
+    namespace range
-    ///
-    /// range-based version of the find_end std algorithm
-    ///
-    /// \pre ForwardRange1 is a model of the ForwardRangeConcept
-    /// \pre ForwardRange2 is a model of the ForwardRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template< class ForwardRange1, class ForwardRange2 >
-    inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
-    find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
 
-        return std::find_end(boost::begin(rng1),boost::end(rng1),
+/// \brief template function find_end
-                             boost::begin(rng2),boost::end(rng2));
+///
-    }
+/// range-based version of the find_end std algorithm
-
+///
-    /// \overload
+/// \pre ForwardRange1 is a model of the ForwardRangeConcept
-    template< class ForwardRange1, class ForwardRange2 >
+/// \pre ForwardRange2 is a model of the ForwardRangeConcept
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2)
+template< class ForwardRange1, class ForwardRange2 >
-    {
+inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2)
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+{
-
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
-        return std::find_end(boost::begin(rng1),boost::end(rng1),
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
-                             boost::begin(rng2),boost::end(rng2));
-    }
-
-    /// \overload
-    template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
-    find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return std::find_end(boost::begin(rng1),boost::end(rng1),
-                             boost::begin(rng2),boost::end(rng2),pred);
-    }
-
-    /// \overload
-    template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
-    find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return std::find_end(boost::begin(rng1),boost::end(rng1),
-                             boost::begin(rng2),boost::end(rng2),pred);
-    }
-
-    /// \overload
-    template< range_return_value re, class ForwardRange1, class ForwardRange2 >
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
-    find_end(ForwardRange1& rng1, const ForwardRange2& rng2)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return range_return<ForwardRange1,re>::
-            pack(std::find_end(boost::begin(rng1), boost::end(rng1),
-                               boost::begin(rng2), boost::end(rng2)),
-                 rng1);
-    }
-
-    /// \overload
-    template< range_return_value re, class ForwardRange1, class ForwardRange2 >
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
-    find_end(const ForwardRange1& rng1, const ForwardRange2& rng2)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return range_return<const ForwardRange1,re>::
-            pack(std::find_end(boost::begin(rng1), boost::end(rng1),
-                               boost::begin(rng2), boost::end(rng2)),
-                 rng1);
-    }
-
-    /// \overload
-    template< range_return_value re, class ForwardRange1, class ForwardRange2,
-              class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
-    find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return range_return<ForwardRange1,re>::
-            pack(std::find_end(boost::begin(rng1), boost::end(rng1),
-                               boost::begin(rng2), boost::end(rng2), pred),
-                 rng1);
-    }
-
-    /// \overload
-    template< range_return_value re, class ForwardRange1, class ForwardRange2,
-              class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
-    find_end(const ForwardRange1& rng1, const ForwardRange2& rng2,
-             BinaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return range_return<const ForwardRange1,re>::
-            pack(std::find_end(boost::begin(rng1), boost::end(rng1),
-                               boost::begin(rng2), boost::end(rng2), pred),
-                 rng1);
-    }
 
+    return std::find_end(boost::begin(rng1),boost::end(rng1),
+                         boost::begin(rng2),boost::end(rng2));
 }
 
+/// \overload
+template< class ForwardRange1, class ForwardRange2 >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
+find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2)
+{
+
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return std::find_end(boost::begin(rng1),boost::end(rng1),
+                         boost::begin(rng2),boost::end(rng2));
+}
+
+/// \overload
+template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
+find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return std::find_end(boost::begin(rng1),boost::end(rng1),
+                         boost::begin(rng2),boost::end(rng2),pred);
+}
+
+/// \overload
+template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
+find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return std::find_end(boost::begin(rng1),boost::end(rng1),
+                         boost::begin(rng2),boost::end(rng2),pred);
+}
+
+/// \overload
+template< range_return_value re, class ForwardRange1, class ForwardRange2 >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+find_end(ForwardRange1& rng1, const ForwardRange2& rng2)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return range_return<ForwardRange1,re>::
+        pack(std::find_end(boost::begin(rng1), boost::end(rng1),
+                           boost::begin(rng2), boost::end(rng2)),
+             rng1);
+}
+
+/// \overload
+template< range_return_value re, class ForwardRange1, class ForwardRange2 >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
+find_end(const ForwardRange1& rng1, const ForwardRange2& rng2)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return range_return<const ForwardRange1,re>::
+        pack(std::find_end(boost::begin(rng1), boost::end(rng1),
+                           boost::begin(rng2), boost::end(rng2)),
+             rng1);
+}
+
+/// \overload
+template< range_return_value re, class ForwardRange1, class ForwardRange2,
+          class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return range_return<ForwardRange1,re>::
+        pack(std::find_end(boost::begin(rng1), boost::end(rng1),
+                           boost::begin(rng2), boost::end(rng2), pred),
+             rng1);
+}
+
+/// \overload
+template< range_return_value re, class ForwardRange1, class ForwardRange2,
+          class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
+find_end(const ForwardRange1& rng1, const ForwardRange2& rng2,
+         BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return range_return<const ForwardRange1,re>::
+        pack(std::find_end(boost::begin(rng1), boost::end(rng1),
+                           boost::begin(rng2), boost::end(rng2), pred),
+             rng1);
+}
+
+    } // namespace range
+    using range::find_end;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/find_first_of.hpp

@@ -18,122 +18,127 @@
 
 namespace boost
 {
-    /// \brief template function find_first_of
+    namespace range
-    ///
-    /// range-based version of the find_first_of std algorithm
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre ForwardRange2 is a model of the ForwardRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template< class SinglePassRange1, class ForwardRange2 >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
-    find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2)
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
 
-        return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+/// \brief template function find_first_of
-                                  boost::begin(rng2),boost::end(rng2));
+///
-    }
+/// range-based version of the find_first_of std algorithm
-
+///
-    /// \overload
+/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    template< class SinglePassRange1, class ForwardRange2 >
+/// \pre ForwardRange2 is a model of the ForwardRangeConcept
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    find_first_of(SinglePassRange1 const & rng1, ForwardRange2 const & rng2)
+template< class SinglePassRange1, class ForwardRange2 >
-    {
+inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2)
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+{
-
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
-        return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
-                                  boost::begin(rng2),boost::end(rng2));
-    }
-
-    /// \overload
-    template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
-    find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return std::find_first_of(boost::begin(rng1),boost::end(rng1),
-                                  boost::begin(rng2),boost::end(rng2),pred);
-    }
-
-    /// \overload
-    template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
-    find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
-                  BinaryPredicate pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return std::find_first_of(boost::begin(rng1),boost::end(rng1),
-                                  boost::begin(rng2),boost::end(rng2),pred);
-    }
-
-// range return overloads
-    /// \overload
-    template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
-    inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
-    find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return range_return<SinglePassRange1,re>::
-            pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
-                                    boost::begin(rng2), boost::end(rng2)),
-                 rng1);
-    }
-
-    /// \overload
-    template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
-    inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
-    find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return range_return<const SinglePassRange1,re>::
-            pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
-                                    boost::begin(rng2), boost::end(rng2)),
-                 rng1);
-    }
-
-    /// \overload
-    template< range_return_value re, class SinglePassRange1, class ForwardRange2,
-              class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
-    find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2,
-                  BinaryPredicate pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return range_return<SinglePassRange1,re>::
-            pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
-                                    boost::begin(rng2), boost::end(rng2), pred),
-                 rng1);
-    }
-
-    /// \overload
-    template< range_return_value re, class SinglePassRange1, class ForwardRange2,
-              class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
-    find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
-                  BinaryPredicate pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-
-        return range_return<const SinglePassRange1,re>::
-            pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
-                                    boost::begin(rng2), boost::end(rng2),pred),
-                 rng1);
-    }
 
+    return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+                              boost::begin(rng2),boost::end(rng2));
 }
 
+/// \overload
+template< class SinglePassRange1, class ForwardRange2 >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
+find_first_of(SinglePassRange1 const & rng1, ForwardRange2 const & rng2)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+                              boost::begin(rng2),boost::end(rng2));
+}
+
+/// \overload
+template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
+find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+                              boost::begin(rng2),boost::end(rng2),pred);
+}
+
+/// \overload
+template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
+find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
+              BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+                              boost::begin(rng2),boost::end(rng2),pred);
+}
+
+// range return overloads
+/// \overload
+template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
+inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
+find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return range_return<SinglePassRange1,re>::
+        pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
+                                boost::begin(rng2), boost::end(rng2)),
+             rng1);
+}
+
+/// \overload
+template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
+inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
+find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return range_return<const SinglePassRange1,re>::
+        pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
+                                boost::begin(rng2), boost::end(rng2)),
+             rng1);
+}
+
+/// \overload
+template< range_return_value re, class SinglePassRange1, class ForwardRange2,
+          class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
+find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2,
+              BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return range_return<SinglePassRange1,re>::
+        pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
+                                boost::begin(rng2), boost::end(rng2), pred),
+             rng1);
+}
+
+/// \overload
+template< range_return_value re, class SinglePassRange1, class ForwardRange2,
+          class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
+find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
+              BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange2> ));
+
+    return range_return<const SinglePassRange1,re>::
+        pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
+                                boost::begin(rng2), boost::end(rng2),pred),
+             rng1);
+}
+
+    } // namespace range
+    using range::find_first_of;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/find_if.hpp

@@ -18,52 +18,56 @@
 
 namespace boost
 {
-    /// \brief template function find_if
+    namespace range
-    ///
-    /// range-based version of the find_if std algorithm
-    ///
-    /// \pre SinglePassRange is a model of the SinglePassRangeConcept
-    /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
-    template< class SinglePassRange, class UnaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
-    find_if( SinglePassRange& rng, UnaryPredicate pred )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+
-        return std::find_if(boost::begin(rng), boost::end(rng), pred);
+/// \brief template function find_if
-    }
+///
-    /// \overload
+/// range-based version of the find_if std algorithm
-    template< class SinglePassRange, class UnaryPredicate >
+///
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
-    find_if( const SinglePassRange& rng, UnaryPredicate pred )
+/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
-    {
+template< class SinglePassRange, class UnaryPredicate >
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
-        return std::find_if(boost::begin(rng), boost::end(rng), pred);
+find_if( SinglePassRange& rng, UnaryPredicate pred )
-    }
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+    return std::find_if(boost::begin(rng), boost::end(rng), pred);
+}
+/// \overload
+template< class SinglePassRange, class UnaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
+find_if( const SinglePassRange& rng, UnaryPredicate pred )
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return std::find_if(boost::begin(rng), boost::end(rng), pred);
+}
 
 // range_return overloads
 
-    /// \overload
+/// \overload
-    template< range_return_value re, class SinglePassRange, class UnaryPredicate >
+template< range_return_value re, class SinglePassRange, class UnaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
-    find_if( SinglePassRange& rng, UnaryPredicate pred )
+find_if( SinglePassRange& rng, UnaryPredicate pred )
-    {
+{
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
-        return range_return<SinglePassRange,re>::
+    return range_return<SinglePassRange,re>::
-            pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
+        pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
-                 rng);
+             rng);
-    }
+}
-    /// \overload
+/// \overload
-    template< range_return_value re, class SinglePassRange, class UnaryPredicate >
+template< range_return_value re, class SinglePassRange, class UnaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
-    find_if( const SinglePassRange& rng, UnaryPredicate pred )
+find_if( const SinglePassRange& rng, UnaryPredicate pred )
-    {
+{
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
-        return range_return<const SinglePassRange,re>::
+    return range_return<const SinglePassRange,re>::
-            pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
+        pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
-                 rng);
+             rng);
-    }
-
-
 }
 
+    } // namespace range
+    using range::find_if;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/for_each.hpp

@@ -17,26 +17,32 @@
 
 namespace boost
 {
-    /// \brief template function for_each
+    namespace range
-    ///
-    /// range-based version of the for_each std algorithm
-    ///
-    /// \pre SinglePassRange is a model of the SinglePassRangeConcept
-    /// \pre UnaryFunction is a model of the UnaryFunctionConcept
-    template< class SinglePassRange, class UnaryFunction >
-    inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
     {
-        boost::function_requires< SinglePassRangeConcept< SinglePassRange > >();
-        return std::for_each(boost::begin(rng),boost::end(rng),fun);
-    }
 
-    /// \overload
+/// \brief template function for_each
-    template< class SinglePassRange, class UnaryFunction >
+///
-    inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun)
+/// range-based version of the for_each std algorithm
-    {
+///
-        boost::function_requires< SinglePassRangeConcept< SinglePassRange > >();
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
-        return std::for_each(boost::begin(rng),boost::end(rng),fun);
+/// \pre UnaryFunction is a model of the UnaryFunctionConcept
-    }
+template< class SinglePassRange, class UnaryFunction >
+inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+    return std::for_each(boost::begin(rng),boost::end(rng),fun);
+}
+
+/// \overload
+template< class SinglePassRange, class UnaryFunction >
+inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return std::for_each(boost::begin(rng),boost::end(rng),fun);
+}
+
+    } // namespace range
+    using range::for_each;
 } // namespace boost
 
 #endif // include guard

include/boost/range/algorithm/generate.hpp

@@ -17,28 +17,33 @@
 
 namespace boost
 {
-    /// \brief template function generate
+    namespace range
-    ///
-    /// range-based version of the generate std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    /// \pre Generator is a model of the UnaryFunctionConcept
-    template< class ForwardRange, class Generator >
-    inline ForwardRange& generate( ForwardRange& rng, Generator gen )
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+/// \brief template function generate
-        std::generate(boost::begin(rng), boost::end(rng), gen);
+///
-        return rng;
+/// range-based version of the generate std algorithm
-    }
+///
-
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-    /// \overload
+/// \pre Generator is a model of the UnaryFunctionConcept
-    template< class ForwardRange, class Generator >
+template< class ForwardRange, class Generator >
-    inline const ForwardRange& generate(const ForwardRange& rng, Generator gen)
+inline ForwardRange& generate( ForwardRange& rng, Generator gen )
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-        std::generate(boost::begin(rng), boost::end(rng), gen);
+    std::generate(boost::begin(rng), boost::end(rng), gen);
-        return rng;
+    return rng;
-    }
 }
 
+/// \overload
+template< class ForwardRange, class Generator >
+inline const ForwardRange& generate(const ForwardRange& rng, Generator gen)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    std::generate(boost::begin(rng), boost::end(rng), gen);
+    return rng;
+}
+
+    } // namespace range
+    using range::generate;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/heap_algorithm.hpp

@@ -17,153 +17,162 @@
 
 namespace boost
 {
-    /// \brief template function push_heap
+    namespace range
-    ///
-    /// range-based version of the push_heap std algorithm
-    ///
-    /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-    /// \pre Compare is a model of the BinaryPredicateConcept
-    template<class RandomAccessRange>
-    inline void push_heap(RandomAccessRange& rng)
     {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::push_heap(boost::begin(rng), boost::end(rng));
-    }
 
-    /// \overload
+/// \brief template function push_heap
-    template<class RandomAccessRange>
+///
-    inline void push_heap(const RandomAccessRange& rng)
+/// range-based version of the push_heap std algorithm
-    {
+///
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-        std::push_heap(boost::begin(rng), boost::end(rng));
+/// \pre Compare is a model of the BinaryPredicateConcept
-    }
+template<class RandomAccessRange>
-
+inline void push_heap(RandomAccessRange& rng)
-    /// \overload
+{
-    template<class RandomAccessRange, class Compare>
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
-    inline void push_heap(RandomAccessRange& rng, Compare comp_pred)
+    std::push_heap(boost::begin(rng), boost::end(rng));
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    }
-
-    /// \overload
-    template<class RandomAccessRange, class Compare>
-    inline void push_heap(const RandomAccessRange& rng, Compare comp_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    }
-
-    /// \brief template function pop_heap
-    ///
-    /// range-based version of the pop_heap std algorithm
-    ///
-    /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-    /// \pre Compare is a model of the BinaryPredicateConcept
-    template<class RandomAccessRange>
-    inline void pop_heap(RandomAccessRange& rng)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::pop_heap(boost::begin(rng), boost::end(rng));
-    }
-
-    /// \overload
-    template<class RandomAccessRange>
-    inline void pop_heap(const RandomAccessRange& rng)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::pop_heap(boost::begin(rng),boost::end(rng));
-    }
-
-    /// \overload
-    template<class RandomAccessRange, class Compare>
-    inline void pop_heap(RandomAccessRange& rng, Compare comp_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    }
-
-    /// \overload
-    template<class RandomAccessRange, class Compare>
-    inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    }
-
-    /// \brief template function make_heap
-    ///
-    /// range-based version of the make_heap std algorithm
-    ///
-    /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-    /// \pre Compare is a model of the BinaryPredicateConcept
-    template<class RandomAccessRange>
-    inline void make_heap(RandomAccessRange& rng)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::make_heap(boost::begin(rng), boost::end(rng));
-    }
-
-    /// \overload
-    template<class RandomAccessRange>
-    inline void make_heap(const RandomAccessRange& rng)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::make_heap(boost::begin(rng),boost::end(rng));
-    }
-
-    /// \overload
-    template<class RandomAccessRange, class Compare>
-    inline void make_heap(RandomAccessRange& rng, Compare comp_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    }
-
-    /// \overload
-    template<class RandomAccessRange, class Compare>
-    inline void make_heap(const RandomAccessRange& rng, Compare comp_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    }
-
-    /// \brief template function sort_heap
-    ///
-    /// range-based version of the sort_heap std algorithm
-    ///
-    /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-    /// \pre Compare is a model of the BinaryPredicateConcept
-    template<class RandomAccessRange>
-    inline void sort_heap(RandomAccessRange& rng)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::sort_heap(boost::begin(rng), boost::end(rng));
-    }
-
-    /// \overload
-    template<class RandomAccessRange>
-    inline void sort_heap(const RandomAccessRange& rng)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::sort_heap(boost::begin(rng), boost::end(rng));
-    }
-
-    /// \overload
-    template<class RandomAccessRange, class Compare>
-    inline void sort_heap(RandomAccessRange& rng, Compare comp_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    }
-
-    /// \overload
-    template<class RandomAccessRange, class Compare>
-    inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    }
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline void push_heap(const RandomAccessRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::push_heap(boost::begin(rng), boost::end(rng));
+}
+
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline void push_heap(RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
+}
+
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline void push_heap(const RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
+}
+
+/// \brief template function pop_heap
+///
+/// range-based version of the pop_heap std algorithm
+///
+/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+/// \pre Compare is a model of the BinaryPredicateConcept
+template<class RandomAccessRange>
+inline void pop_heap(RandomAccessRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::pop_heap(boost::begin(rng), boost::end(rng));
+}
+
+/// \overload
+template<class RandomAccessRange>
+inline void pop_heap(const RandomAccessRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::pop_heap(boost::begin(rng),boost::end(rng));
+}
+
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline void pop_heap(RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
+}
+
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
+}
+
+/// \brief template function make_heap
+///
+/// range-based version of the make_heap std algorithm
+///
+/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+/// \pre Compare is a model of the BinaryPredicateConcept
+template<class RandomAccessRange>
+inline void make_heap(RandomAccessRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::make_heap(boost::begin(rng), boost::end(rng));
+}
+
+/// \overload
+template<class RandomAccessRange>
+inline void make_heap(const RandomAccessRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::make_heap(boost::begin(rng),boost::end(rng));
+}
+
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline void make_heap(RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
+}
+
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline void make_heap(const RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
+}
+
+/// \brief template function sort_heap
+///
+/// range-based version of the sort_heap std algorithm
+///
+/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+/// \pre Compare is a model of the BinaryPredicateConcept
+template<class RandomAccessRange>
+inline void sort_heap(RandomAccessRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::sort_heap(boost::begin(rng), boost::end(rng));
+}
+
+/// \overload
+template<class RandomAccessRange>
+inline void sort_heap(const RandomAccessRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::sort_heap(boost::begin(rng), boost::end(rng));
+}
+
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline void sort_heap(RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
+}
+
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
+}
+
+    } // namespace range
+    using range::push_heap;
+    using range::pop_heap;
+    using range::make_heap;
+    using range::sort_heap;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/inplace_merge.hpp

@@ -17,52 +17,58 @@
 
 namespace boost
 {
-    /// \brief template function inplace_merge
+    namespace range
-    ///
-    /// range-based version of the inplace_merge std algorithm
-    ///
-    /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class BidirectionalRange>
-    inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
-        BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type middle)
     {
-        boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
-        std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
-        return rng;
-    }
 
-    /// \overload
+/// \brief template function inplace_merge
-    template<class BidirectionalRange>
+///
-    inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
+/// range-based version of the inplace_merge std algorithm
-        BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle)
+///
-    {
+/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
-        boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-        std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
+template<class BidirectionalRange>
-        return rng;
+inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
-    }
+    BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type middle)
-
+{
-    /// \overload
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
-    template<class BidirectionalRange, class BinaryPredicate>
+    std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
-    inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
+    return rng;
-        BOOST_DEDUCED_TYPENAME boost::range_iterator<BidirectionalRange>::type middle,
-        BinaryPredicate pred)
-    {
-        boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
-        std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
-        return rng;
-    }
-
-    /// \overload
-    template<class BidirectionalRange, class BinaryPredicate>
-    inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
-        BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle,
-        BinaryPredicate pred)
-    {
-        boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
-        std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
-        return rng;
-    }
 }
 
+/// \overload
+template<class BidirectionalRange>
+inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
+    BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+    std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
+    return rng;
+}
+
+/// \overload
+template<class BidirectionalRange, class BinaryPredicate>
+inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
+    BOOST_DEDUCED_TYPENAME boost::range_iterator<BidirectionalRange>::type middle,
+    BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
+    return rng;
+}
+
+/// \overload
+template<class BidirectionalRange, class BinaryPredicate>
+inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
+    BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle,
+    BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+    std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
+    return rng;
+}
+
+    } // namespace range
+    using range::inplace_merge;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/lexicographical_compare.hpp

@@ -17,36 +17,42 @@
 
 namespace boost
 {
-    /// \brief template function lexicographic_compare
+    namespace range
-    ///
-    /// range-based version of the lexicographic_compare std algorithm
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    template<class SinglePassRange1, class SinglePassRange2>
-    inline bool lexicographical_compare(const SinglePassRange1& rng1,
-                                        const SinglePassRange2& rng2)
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-        return std::lexicographical_compare(
-            boost::begin(rng1), boost::end(rng1),
-            boost::begin(rng2), boost::end(rng2));
-    }
 
-    /// \overload
+/// \brief template function lexicographic_compare
-    template<class SinglePassRange1, class SinglePassRange2,
+///
-             class BinaryPredicate>
+/// range-based version of the lexicographic_compare std algorithm
-    inline bool lexicographical_compare(const SinglePassRange1& rng1,
+///
-                                        const SinglePassRange2& rng2,
+/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-                                        BinaryPredicate pred)
+/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    {
+template<class SinglePassRange1, class SinglePassRange2>
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+inline bool lexicographical_compare(const SinglePassRange1& rng1,
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+                                    const SinglePassRange2& rng2)
-        return std::lexicographical_compare(
+{
-            boost::begin(rng1), boost::end(rng1),
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-            boost::begin(rng2), boost::end(rng2), pred);
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
-    }
+    return std::lexicographical_compare(
+        boost::begin(rng1), boost::end(rng1),
+        boost::begin(rng2), boost::end(rng2));
 }
 
+/// \overload
+template<class SinglePassRange1, class SinglePassRange2,
+         class BinaryPredicate>
+inline bool lexicographical_compare(const SinglePassRange1& rng1,
+                                    const SinglePassRange2& rng2,
+                                    BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::lexicographical_compare(
+        boost::begin(rng1), boost::end(rng1),
+        boost::begin(rng2), boost::end(rng2), pred);
+}
+
+    } // namespace range
+    using range::lexicographical_compare;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/lower_bound.hpp

@@ -18,82 +18,88 @@
 
 namespace boost
 {
-    /// \brief template function lower_bound
+    namespace range
-    ///
-    /// range-based version of the lower_bound std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    template< class ForwardRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-    lower_bound( ForwardRange& rng, Value val )
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
-        return std::lower_bound(boost::begin(rng), boost::end(rng), val);
+/// \brief template function lower_bound
-    }
+///
-    /// \overload
+/// range-based version of the lower_bound std algorithm
-    template< class ForwardRange, class Value >
+///
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-    lower_bound( const ForwardRange& rng, Value val )
+template< class ForwardRange, class Value >
-    {
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+lower_bound( ForwardRange& rng, Value val )
-        return std::lower_bound(boost::begin(rng), boost::end(rng), val);
+{
-    }
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    /// \overload
+    return std::lower_bound(boost::begin(rng), boost::end(rng), val);
-    template< class ForwardRange, class Value, class SortPredicate >
+}
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+/// \overload
-    lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
+template< class ForwardRange, class Value >
-    {
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+lower_bound( const ForwardRange& rng, Value val )
-        return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
+{
-    }
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    /// \overload
+    return std::lower_bound(boost::begin(rng), boost::end(rng), val);
-    template< class ForwardRange, class Value, class SortPredicate >
+}
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+/// \overload
-    lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+template< class ForwardRange, class Value, class SortPredicate >
-    {
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
-        return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
+{
-    }
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    /// \overload
+    return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
-    template< range_return_value re, class ForwardRange, class Value >
+}
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+/// \overload
-    lower_bound( ForwardRange& rng, Value val )
+template< class ForwardRange, class Value, class SortPredicate >
-    {
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
-        return range_return<ForwardRange,re>::
+{
-            pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-                 rng);
+    return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
-    }
+}
-    /// \overload
+/// \overload
-    template< range_return_value re, class ForwardRange, class Value >
+template< range_return_value re, class ForwardRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-    lower_bound( const ForwardRange& rng, Value val )
+lower_bound( ForwardRange& rng, Value val )
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-        return range_return<const ForwardRange,re>::
+    return range_return<ForwardRange,re>::
-            pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
+        pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
-                 rng);
+             rng);
-    }
+}
-    /// \overload
+/// \overload
-    template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
+template< range_return_value re, class ForwardRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
-    lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
+lower_bound( const ForwardRange& rng, Value val )
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-        return range_return<ForwardRange,re>::
+    return range_return<const ForwardRange,re>::
-            pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
+        pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
-                 rng);
+             rng);
-    }
+}
-    /// \overload
+/// \overload
-    template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
+template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-    lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-        return range_return<const ForwardRange,re>::
+    return range_return<ForwardRange,re>::
-            pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
+        pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
-                 rng);
+             rng);
-    }
+}
+/// \overload
+template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::
+        pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
+             rng);
 }
 
+    } // namespace range
+    using range::lower_bound;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/max_element.hpp

@@ -18,92 +18,98 @@
 
 namespace boost
 {
-    /// \brief template function max_element
+    namespace range
-    ///
-    /// range-based version of the max_element std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class ForwardRange>
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-    max_element(ForwardRange& rng)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return std::max_element(boost::begin(rng), boost::end(rng));
-    }
 
-    /// \overload
+/// \brief template function max_element
-    template<class ForwardRange>
+///
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+/// range-based version of the max_element std algorithm
-    max_element(const ForwardRange& rng)
+///
-    {
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-        return std::max_element(boost::begin(rng), boost::end(rng));
+template<class ForwardRange>
-    }
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+max_element(ForwardRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return std::max_element(boost::begin(rng), boost::end(rng));
+}
 
-    /// \overload
+/// \overload
-    template<class ForwardRange, class BinaryPredicate>
+template<class ForwardRange>
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
-    max_element(ForwardRange& rng, BinaryPredicate pred)
+max_element(const ForwardRange& rng)
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-        return std::max_element(boost::begin(rng), boost::end(rng), pred);
+    return std::max_element(boost::begin(rng), boost::end(rng));
-    }
+}
 
-    /// \overload
+/// \overload
-    template<class ForwardRange, class BinaryPredicate>
+template<class ForwardRange, class BinaryPredicate>
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-    max_element(const ForwardRange& rng, BinaryPredicate pred)
+max_element(ForwardRange& rng, BinaryPredicate pred)
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-        return std::max_element(boost::begin(rng), boost::end(rng), pred);
+    return std::max_element(boost::begin(rng), boost::end(rng), pred);
-    }
+}
+
+/// \overload
+template<class ForwardRange, class BinaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+max_element(const ForwardRange& rng, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::max_element(boost::begin(rng), boost::end(rng), pred);
+}
 
 // range_return overloads
 
-    /// \overload
+/// \overload
-    template<range_return_value re, class ForwardRange>
+template<range_return_value re, class ForwardRange>
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-    max_element(ForwardRange& rng)
+max_element(ForwardRange& rng)
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-        return range_return<ForwardRange,re>::pack(
+    return range_return<ForwardRange,re>::pack(
-            std::max_element(boost::begin(rng), boost::end(rng)),
+        std::max_element(boost::begin(rng), boost::end(rng)),
-            rng);
+        rng);
-    }
-
-    /// \overload
-    template<range_return_value re, class ForwardRange>
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
-    max_element(const ForwardRange& rng)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return range_return<const ForwardRange,re>::pack(
-            std::max_element(boost::begin(rng), boost::end(rng)),
-            rng);
-    }
-
-    /// \overload
-    template<range_return_value re, class ForwardRange, class BinaryPredicate>
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-    max_element(ForwardRange& rng, BinaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return range_return<ForwardRange,re>::pack(
-            std::max_element(boost::begin(rng), boost::end(rng), pred),
-            rng);
-    }
-
-    /// \overload
-    template<range_return_value re, class ForwardRange, class BinaryPredicate>
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
-    max_element(const ForwardRange& rng, BinaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return range_return<const ForwardRange,re>::pack(
-            std::max_element(boost::begin(rng), boost::end(rng), pred),
-            rng);
-    }
 }
 
+/// \overload
+template<range_return_value re, class ForwardRange>
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+max_element(const ForwardRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::pack(
+        std::max_element(boost::begin(rng), boost::end(rng)),
+        rng);
+}
+
+/// \overload
+template<range_return_value re, class ForwardRange, class BinaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+max_element(ForwardRange& rng, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return range_return<ForwardRange,re>::pack(
+        std::max_element(boost::begin(rng), boost::end(rng), pred),
+        rng);
+}
+
+/// \overload
+template<range_return_value re, class ForwardRange, class BinaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+max_element(const ForwardRange& rng, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::pack(
+        std::max_element(boost::begin(rng), boost::end(rng), pred),
+        rng);
+}
+
+    } // namespace range
+    using range::max_element;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/merge.hpp

@@ -17,39 +17,45 @@
 
 namespace boost
 {
-    /// \brief template function merge
+    namespace range
-    ///
-    /// range-based version of the merge std algorithm
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    ///
-    template<class SinglePassRange1, class SinglePassRange2,
-             class OutputIterator>
-    inline OutputIterator merge(const SinglePassRange1& rng1,
-                                const SinglePassRange2& rng2,
-                                OutputIterator          out)
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-        return std::merge(boost::begin(rng1), boost::end(rng1),
-                          boost::begin(rng2), boost::end(rng2), out);
-    }
 
-    /// \overload
+/// \brief template function merge
-    template<class SinglePassRange1, class SinglePassRange2,
+///
-             class OutputIterator, class BinaryPredicate>
+/// range-based version of the merge std algorithm
-    inline OutputIterator merge(const SinglePassRange1& rng1,
+///
-                                const SinglePassRange2& rng2,
+/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-                                OutputIterator          out,
+/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-                                BinaryPredicate         pred)
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    {
+///
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+template<class SinglePassRange1, class SinglePassRange2,
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+         class OutputIterator>
-        return std::merge(boost::begin(rng1), boost::end(rng1),
+inline OutputIterator merge(const SinglePassRange1& rng1,
-                          boost::begin(rng2), boost::end(rng2), out, pred);
+                            const SinglePassRange2& rng2,
-    }
+                            OutputIterator          out)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::merge(boost::begin(rng1), boost::end(rng1),
+                      boost::begin(rng2), boost::end(rng2), out);
 }
 
+/// \overload
+template<class SinglePassRange1, class SinglePassRange2,
+         class OutputIterator, class BinaryPredicate>
+inline OutputIterator merge(const SinglePassRange1& rng1,
+                            const SinglePassRange2& rng2,
+                            OutputIterator          out,
+                            BinaryPredicate         pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::merge(boost::begin(rng1), boost::end(rng1),
+                      boost::begin(rng2), boost::end(rng2), out, pred);
+}
+
+    } // namespace range
+    using range::merge;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/min_element.hpp

@@ -18,92 +18,98 @@
 
 namespace boost
 {
-    /// \brief template function min_element
+    namespace range
-    ///
-    /// range-based version of the min_element std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class ForwardRange>
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-    min_element(ForwardRange& rng)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return std::min_element(boost::begin(rng), boost::end(rng));
-    }
 
-    /// \overload
+/// \brief template function min_element
-    template<class ForwardRange>
+///
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+/// range-based version of the min_element std algorithm
-    min_element(const ForwardRange& rng)
+///
-    {
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-        return std::min_element(boost::begin(rng), boost::end(rng));
+template<class ForwardRange>
-    }
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+min_element(ForwardRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return std::min_element(boost::begin(rng), boost::end(rng));
+}
 
-    /// \overload
+/// \overload
-    template<class ForwardRange, class BinaryPredicate>
+template<class ForwardRange>
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
-    min_element(ForwardRange& rng, BinaryPredicate pred)
+min_element(const ForwardRange& rng)
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-        return std::min_element(boost::begin(rng), boost::end(rng), pred);
+    return std::min_element(boost::begin(rng), boost::end(rng));
-    }
+}
 
-    /// \overload
+/// \overload
-    template<class ForwardRange, class BinaryPredicate>
+template<class ForwardRange, class BinaryPredicate>
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-    min_element(const ForwardRange& rng, BinaryPredicate pred)
+min_element(ForwardRange& rng, BinaryPredicate pred)
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-        return std::min_element(boost::begin(rng), boost::end(rng), pred);
+    return std::min_element(boost::begin(rng), boost::end(rng), pred);
-    }
+}
+
+/// \overload
+template<class ForwardRange, class BinaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+min_element(const ForwardRange& rng, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::min_element(boost::begin(rng), boost::end(rng), pred);
+}
 
 // range_return overloads
 
-    /// \overload
+/// \overload
-    template<range_return_value re, class ForwardRange>
+template<range_return_value re, class ForwardRange>
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-    min_element(ForwardRange& rng)
+min_element(ForwardRange& rng)
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-        return range_return<ForwardRange,re>::pack(
+    return range_return<ForwardRange,re>::pack(
-            std::min_element(boost::begin(rng), boost::end(rng)),
+        std::min_element(boost::begin(rng), boost::end(rng)),
-            rng);
+        rng);
-    }
-
-    /// \overload
-    template<range_return_value re, class ForwardRange>
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
-    min_element(const ForwardRange& rng)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return range_return<const ForwardRange,re>::pack(
-            std::min_element(boost::begin(rng), boost::end(rng)),
-            rng);
-    }
-
-    /// \overload
-    template<range_return_value re, class ForwardRange, class BinaryPredicate>
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-    min_element(ForwardRange& rng, BinaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return range_return<ForwardRange,re>::pack(
-            std::min_element(boost::begin(rng), boost::end(rng), pred),
-            rng);
-    }
-
-    /// \overload
-    template<range_return_value re, class ForwardRange, class BinaryPredicate>
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
-    min_element(const ForwardRange& rng, BinaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return range_return<const ForwardRange,re>::pack(
-            std::min_element(boost::begin(rng), boost::end(rng), pred),
-            rng);
-    }
 }
 
+/// \overload
+template<range_return_value re, class ForwardRange>
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+min_element(const ForwardRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::pack(
+        std::min_element(boost::begin(rng), boost::end(rng)),
+        rng);
+}
+
+/// \overload
+template<range_return_value re, class ForwardRange, class BinaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+min_element(ForwardRange& rng, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return range_return<ForwardRange,re>::pack(
+        std::min_element(boost::begin(rng), boost::end(rng), pred),
+        rng);
+}
+
+/// \overload
+template<range_return_value re, class ForwardRange, class BinaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+min_element(const ForwardRange& rng, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::pack(
+        std::min_element(boost::begin(rng), boost::end(rng), pred),
+        rng);
+}
+
+    } // namespace range
+    using range::min_element;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/mismatch.hpp

@@ -57,126 +57,139 @@ namespace boost
             return std::pair<SinglePassTraversalReadableIterator1,
                              SinglePassTraversalReadableIterator2>(first1, first2);
         }
-    }
+    } // namespace range_detail
 
-    /// \brief template function mismatch
+    namespace range
-    ///
-    /// range-based version of the mismatch std algorithm
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template< class SinglePassRange1, class SinglePassRange2 >
-    inline std::pair<
-        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
-        BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
-    mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2)
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+/// \brief template function mismatch
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+///
+/// range-based version of the mismatch std algorithm
+///
+/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+template< class SinglePassRange1, class SinglePassRange2 >
+inline std::pair<
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
+mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
 
-        return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
+    return ::boost::range_detail::mismatch_impl(
-            boost::begin(rng2), boost::end(rng2));
+        ::boost::begin(rng1), ::boost::end(rng1),
-    }
+        ::boost::begin(rng2), ::boost::end(rng2));
-
-    /// \overload
-    template< class SinglePassRange1, class SinglePassRange2 >
-    inline std::pair<
-        BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
-        BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
-    mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-
-        return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
-            boost::begin(rng2), boost::end(rng2));
-    }
-
-    /// \overload
-    template< class SinglePassRange1, class SinglePassRange2 >
-    inline std::pair<
-        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
-        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
-    mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-
-        return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
-            boost::begin(rng2), boost::end(rng2));
-    }
-
-    /// \overload
-    template< class SinglePassRange1, class SinglePassRange2 >
-    inline std::pair<
-        BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
-        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
-    mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-
-        return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
-            boost::begin(rng2), boost::end(rng2));
-    }
-
-
-    /// \overload
-    template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
-    inline std::pair<
-        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
-        BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
-    mismatch(SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-
-        return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
-            boost::begin(rng2), boost::end(rng2), pred);
-    }
-
-    /// \overload
-    template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
-    inline std::pair<
-        BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
-        BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
-    mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-
-        return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
-            boost::begin(rng2), boost::end(rng2), pred);
-    }
-
-    /// \overload
-    template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
-    inline std::pair<
-        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
-        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
-    mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-
-        return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
-            boost::begin(rng2), boost::end(rng2), pred);
-    }
-
-    /// \overload
-    template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
-    inline std::pair<
-        BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
-        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
-    mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-
-        return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
-            boost::begin(rng2), boost::end(rng2), pred);
-    }
 }
 
+/// \overload
+template< class SinglePassRange1, class SinglePassRange2 >
+inline std::pair<
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
+mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+
+    return ::boost::range_detail::mismatch_impl(
+        ::boost::begin(rng1), ::boost::end(rng1),
+        ::boost::begin(rng2), ::boost::end(rng2));
+}
+
+/// \overload
+template< class SinglePassRange1, class SinglePassRange2 >
+inline std::pair<
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
+mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+
+    return ::boost::range_detail::mismatch_impl(
+        ::boost::begin(rng1), ::boost::end(rng1),
+        ::boost::begin(rng2), ::boost::end(rng2));
+}
+
+/// \overload
+template< class SinglePassRange1, class SinglePassRange2 >
+inline std::pair<
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
+mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+
+    return ::boost::range_detail::mismatch_impl(
+        ::boost::begin(rng1), ::boost::end(rng1),
+        ::boost::begin(rng2), ::boost::end(rng2));
+}
+
+
+/// \overload
+template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+inline std::pair<
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
+mismatch(SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+
+    return ::boost::range_detail::mismatch_impl(
+        ::boost::begin(rng1), ::boost::end(rng1),
+        ::boost::begin(rng2), ::boost::end(rng2), pred);
+}
+
+/// \overload
+template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+inline std::pair<
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
+mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+
+    return ::boost::range_detail::mismatch_impl(
+        ::boost::begin(rng1), ::boost::end(rng1),
+        ::boost::begin(rng2), ::boost::end(rng2), pred);
+}
+
+/// \overload
+template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+inline std::pair<
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
+mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+
+    return ::boost::range_detail::mismatch_impl(
+        ::boost::begin(rng1), ::boost::end(rng1),
+        ::boost::begin(rng2), ::boost::end(rng2), pred);
+}
+
+/// \overload
+template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+inline std::pair<
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
+mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+
+    return ::boost::range_detail::mismatch_impl(
+        ::boost::begin(rng1), ::boost::end(rng1),
+        ::boost::begin(rng2), ::boost::end(rng2), pred);
+}
+
+    } // namespace range
+    using range::mismatch;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/nth_element.hpp

@@ -17,48 +17,54 @@
 
 namespace boost
 {
-    /// \brief template function nth_element
+    namespace range
-    ///
-    /// range-based version of the nth_element std algorithm
-    ///
-    /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class RandomAccessRange>
-    inline void nth_element(RandomAccessRange& rng,
-        BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth)
     {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::nth_element(boost::begin(rng), nth, boost::end(rng));
-    }
 
-    /// \overload
+/// \brief template function nth_element
-    template<class RandomAccessRange>
+///
-    inline void nth_element(const RandomAccessRange& rng,
+/// range-based version of the nth_element std algorithm
-        BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth)
+///
-    {
+/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-        std::nth_element(boost::begin(rng),nth,boost::end(rng));
+template<class RandomAccessRange>
-    }
+inline void nth_element(RandomAccessRange& rng,
-
+    BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth)
-    /// \overload
+{
-    template<class RandomAccessRange, class BinaryPredicate>
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
-    inline void nth_element(RandomAccessRange& rng,
+    std::nth_element(boost::begin(rng), nth, boost::end(rng));
-        BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth,
-        BinaryPredicate sort_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred);
-    }
-
-    /// \overload
-    template<class RandomAccessRange, class BinaryPredicate>
-    inline void nth_element(const RandomAccessRange& rng,
-        BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth,
-        BinaryPredicate sort_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred);
-    }
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline void nth_element(const RandomAccessRange& rng,
+    BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::nth_element(boost::begin(rng),nth,boost::end(rng));
+}
+
+/// \overload
+template<class RandomAccessRange, class BinaryPredicate>
+inline void nth_element(RandomAccessRange& rng,
+    BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth,
+    BinaryPredicate sort_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred);
+}
+
+/// \overload
+template<class RandomAccessRange, class BinaryPredicate>
+inline void nth_element(const RandomAccessRange& rng,
+    BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth,
+    BinaryPredicate sort_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred);
+}
+
+    } // namespace range
+    using range::nth_element;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/partial_sort.hpp

@@ -17,49 +17,55 @@
 
 namespace boost
 {
-    /// \brief template function partial_sort
+    namespace range
-    ///
-    /// range-based version of the partial_sort std algorithm
-    ///
-    /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class RandomAccessRange>
-    inline void partial_sort(RandomAccessRange& rng,
-        BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle)
     {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::partial_sort(boost::begin(rng), middle, boost::end(rng));
-    }
 
-    /// \overload
+/// \brief template function partial_sort
-    template<class RandomAccessRange>
+///
-    inline void partial_sort(const RandomAccessRange& rng,
+/// range-based version of the partial_sort std algorithm
-        BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle)
+///
-    {
+/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-        std::partial_sort(boost::begin(rng), middle, boost::end(rng));
+template<class RandomAccessRange>
-    }
+inline void partial_sort(RandomAccessRange& rng,
-
+    BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle)
-    /// \overload
+{
-    template<class RandomAccessRange, class BinaryPredicate>
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
-    inline void partial_sort(RandomAccessRange& rng,
+    std::partial_sort(boost::begin(rng), middle, boost::end(rng));
-        BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle,
-        BinaryPredicate sort_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::partial_sort(boost::begin(rng), middle, boost::end(rng),
-                            sort_pred);
-    }
-
-    /// \overload
-    template<class RandomAccessRange, class BinaryPredicate>
-    inline void partial_sort(const RandomAccessRange& rng,
-        BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle,
-        BinaryPredicate sort_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred);
-    }
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline void partial_sort(const RandomAccessRange& rng,
+    BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::partial_sort(boost::begin(rng), middle, boost::end(rng));
+}
+
+/// \overload
+template<class RandomAccessRange, class BinaryPredicate>
+inline void partial_sort(RandomAccessRange& rng,
+    BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle,
+    BinaryPredicate sort_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::partial_sort(boost::begin(rng), middle, boost::end(rng),
+                        sort_pred);
+}
+
+/// \overload
+template<class RandomAccessRange, class BinaryPredicate>
+inline void partial_sort(const RandomAccessRange& rng,
+    BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle,
+    BinaryPredicate sort_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred);
+}
+
+    } // namespace range
+    using range::partial_sort;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/partial_sort_copy.hpp

@@ -18,41 +18,47 @@
 
 namespace boost
 {
-    /// \brief template function partial_sort_copy
+    namespace range
-    ///
-    /// range-based version of the partial_sort_copy std algorithm
-    ///
-    /// \pre SinglePassRange is a model of the SinglePassRangeConcept
-    /// \pre RandomAccessRange is a model of the Mutable_RandomAccessRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<typename SinglePassRange, typename RandomAccessRange>
-    inline typename range_iterator<RandomAccessRange>::type
-    partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2)
     {
-        BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
-        BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
-        BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
-        BOOST_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
 
-        return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
+/// \brief template function partial_sort_copy
-            boost::begin(rng2), boost::end(rng2));
+///
-    }
+/// range-based version of the partial_sort_copy std algorithm
+///
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
+/// \pre RandomAccessRange is a model of the Mutable_RandomAccessRangeConcept
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+template<typename SinglePassRange, typename RandomAccessRange>
+inline typename range_iterator<RandomAccessRange>::type
+partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2)
+{
+    BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+    BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
+    BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
+    BOOST_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
 
-    /// \overload
+    return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
-    template<typename SinglePassRange, typename RandomAccessRange,
+        boost::begin(rng2), boost::end(rng2));
-             typename BinaryPredicate>
-    inline typename range_iterator<RandomAccessRange>::type
-    partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2,
-        BinaryPredicate pred)
-    {
-        BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
-        BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
-        BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
-        BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<RandomAccessRange>::type, typename range_value<RandomAccessRange>::type>));
-
-        return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
-            boost::begin(rng2), boost::end(rng2), pred);
-    }
 }
 
+/// \overload
+template<typename SinglePassRange, typename RandomAccessRange,
+         typename BinaryPredicate>
+inline typename range_iterator<RandomAccessRange>::type
+partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2,
+    BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+    BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
+    BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
+    BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<RandomAccessRange>::type, typename range_value<RandomAccessRange>::type>));
+
+    return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
+        boost::begin(rng2), boost::end(rng2), pred);
+}
+
+    } // namespace range
+    using range::partial_sort_copy;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/partition.hpp

@@ -18,51 +18,57 @@
 
 namespace boost
 {
-    /// \brief template function partition
+    namespace range
-    ///
-    /// range-based version of the partition std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    template<class ForwardRange, class UnaryPredicate>
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-    partition(ForwardRange& rng, UnaryPredicate pred)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return std::partition(boost::begin(rng),boost::end(rng),pred);
-    }
 
-    /// \overload
+/// \brief template function partition
-    template<class ForwardRange, class UnaryPredicate>
+///
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+/// range-based version of the partition std algorithm
-    partition(const ForwardRange& rng, UnaryPredicate pred)
+///
-    {
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+template<class ForwardRange, class UnaryPredicate>
-        return std::partition(boost::begin(rng),boost::end(rng),pred);
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-    }
+partition(ForwardRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return std::partition(boost::begin(rng),boost::end(rng),pred);
+}
+
+/// \overload
+template<class ForwardRange, class UnaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+partition(const ForwardRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::partition(boost::begin(rng),boost::end(rng),pred);
+}
 
 // range_return overloads
 
-    /// \overload
+/// \overload
-    template< range_return_value re, class ForwardRange,
+template< range_return_value re, class ForwardRange,
-              class UnaryPredicate >
+          class UnaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-    partition(ForwardRange& rng, UnaryPredicate pred)
+partition(ForwardRange& rng, UnaryPredicate pred)
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-        return boost::range_return<ForwardRange,re>::
+    return boost::range_return<ForwardRange,re>::
-            pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
+        pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
-    }
-
-    /// \overload
-    template< range_return_value re, class ForwardRange,
-              class UnaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
-    partition(const ForwardRange& rng, UnaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return boost::range_return<const ForwardRange,re>::
-            pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
-    }
 }
 
+/// \overload
+template< range_return_value re, class ForwardRange,
+          class UnaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+partition(const ForwardRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return boost::range_return<const ForwardRange,re>::
+        pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
+}
+
+    } // namespace range
+    using range::partition;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/permutation.hpp

@@ -17,101 +17,92 @@
 
 namespace boost
 {
-    /// \brief template function next_permutation
+    namespace range
-    ///
-    /// range-based version of the next_permutation std algorithm
-    ///
-    /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
-    /// \pre Compare is a model of the BinaryPredicateConcept
-    template<class BidirectionalRange>
-    inline bool next_permutation(BidirectionalRange& rng)
     {
-        boost::function_requires<
-            BidirectionalRangeConcept<BidirectionalRange> >();
 
-        return std::next_permutation(boost::begin(rng), boost::end(rng));
+/// \brief template function next_permutation
-    }
+///
-
+/// range-based version of the next_permutation std algorithm
-    /// \overload
+///
-    template<class BidirectionalRange>
+/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
-    inline bool next_permutation(const BidirectionalRange& rng)
+/// \pre Compare is a model of the BinaryPredicateConcept
-    {
+template<class BidirectionalRange>
-        boost::function_requires<
+inline bool next_permutation(BidirectionalRange& rng)
-            BidirectionalRangeConcept<BidirectionalRange> >();
+{
-
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
-        return std::next_permutation(boost::begin(rng), boost::end(rng));
+    return std::next_permutation(boost::begin(rng), boost::end(rng));
-    }
-
-    /// \overload
-    template<class BidirectionalRange, class Compare>
-    inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
-    {
-        boost::function_requires<
-            BidirectionalRangeConcept<BidirectionalRange> >();
-
-        return std::next_permutation(boost::begin(rng), boost::end(rng),
-                                     comp_pred);
-    }
-
-    /// \overload
-    template<class BidirectionalRange, class Compare>
-    inline bool next_permutation(const BidirectionalRange& rng,
-                                 Compare                   comp_pred)
-    {
-        boost::function_requires<
-            BidirectionalRangeConcept<BidirectionalRange> >();
-
-        return std::next_permutation(boost::begin(rng), boost::end(rng),
-                                     comp_pred);
-    }
-
-    /// \brief template function prev_permutation
-    ///
-    /// range-based version of the prev_permutation std algorithm
-    ///
-    /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
-    /// \pre Compare is a model of the BinaryPredicateConcept
-    template<class BidirectionalRange>
-    inline bool prev_permutation(BidirectionalRange& rng)
-    {
-        boost::function_requires<
-            BidirectionalRangeConcept<BidirectionalRange> >();
-
-        return std::prev_permutation(boost::begin(rng), boost::end(rng));
-    }
-
-    /// \overload
-    template<class BidirectionalRange>
-    inline bool prev_permutation(const BidirectionalRange& rng)
-    {
-        boost::function_requires<
-            BidirectionalRangeConcept<BidirectionalRange> >();
-
-        return std::prev_permutation(boost::begin(rng), boost::end(rng));
-    }
-
-    /// \overload
-    template<class BidirectionalRange, class Compare>
-    inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
-    {
-        boost::function_requires<
-            BidirectionalRangeConcept<BidirectionalRange> >();
-
-        return std::prev_permutation(boost::begin(rng), boost::end(rng),
-                                     comp_pred);
-    }
-
-    /// \overload
-    template<class BidirectionalRange, class Compare>
-    inline bool prev_permutation(const BidirectionalRange& rng,
-                                 Compare                   comp_pred)
-    {
-        boost::function_requires<
-            BidirectionalRangeConcept<BidirectionalRange> >();
-
-        return std::prev_permutation(boost::begin(rng), boost::end(rng),
-                                     comp_pred);
-    }
 }
 
+/// \overload
+template<class BidirectionalRange>
+inline bool next_permutation(const BidirectionalRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+    return std::next_permutation(boost::begin(rng), boost::end(rng));
+}
+
+/// \overload
+template<class BidirectionalRange, class Compare>
+inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    return std::next_permutation(boost::begin(rng), boost::end(rng),
+                                 comp_pred);
+}
+
+/// \overload
+template<class BidirectionalRange, class Compare>
+inline bool next_permutation(const BidirectionalRange& rng,
+                             Compare                   comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+    return std::next_permutation(boost::begin(rng), boost::end(rng),
+                                 comp_pred);
+}
+
+/// \brief template function prev_permutation
+///
+/// range-based version of the prev_permutation std algorithm
+///
+/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
+/// \pre Compare is a model of the BinaryPredicateConcept
+template<class BidirectionalRange>
+inline bool prev_permutation(BidirectionalRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    return std::prev_permutation(boost::begin(rng), boost::end(rng));
+}
+
+/// \overload
+template<class BidirectionalRange>
+inline bool prev_permutation(const BidirectionalRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+    return std::prev_permutation(boost::begin(rng), boost::end(rng));
+}
+
+/// \overload
+template<class BidirectionalRange, class Compare>
+inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    return std::prev_permutation(boost::begin(rng), boost::end(rng),
+                                 comp_pred);
+}
+
+/// \overload
+template<class BidirectionalRange, class Compare>
+inline bool prev_permutation(const BidirectionalRange& rng,
+                             Compare                   comp_pred)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+    return std::prev_permutation(boost::begin(rng), boost::end(rng),
+                                 comp_pred);
+}
+
+    } // namespace range
+    using range::next_permutation;
+    using range::prev_permutation;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/random_shuffle.hpp

@@ -17,46 +17,52 @@
 
 namespace boost
 {
-    /// \brief template function random_shuffle
+    namespace range
-    ///
-    /// range-based version of the random_shuffle std algorithm
-    ///
-    /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-    /// \pre Generator is a model of the UnaryFunctionConcept
-    template<class RandomAccessRange>
-    inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
     {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::random_shuffle(boost::begin(rng), boost::end(rng));
-        return rng;
-    }
 
-    /// \overload
+/// \brief template function random_shuffle
-    template<class RandomAccessRange>
+///
-    inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
+/// range-based version of the random_shuffle std algorithm
-    {
+///
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-        std::random_shuffle(boost::begin(rng),boost::end(rng));
+/// \pre Generator is a model of the UnaryFunctionConcept
-        return rng;
+template<class RandomAccessRange>
-    }
+inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
-
+{
-    /// \overload
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
-    template<class RandomAccessRange, class Generator>
+    std::random_shuffle(boost::begin(rng), boost::end(rng));
-    inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
+    return rng;
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
-        return rng;
-    }
-
-    /// \overload
-    template<class RandomAccessRange, class Generator>
-    inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
-        return rng;
-    }
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::random_shuffle(boost::begin(rng),boost::end(rng));
+    return rng;
+}
+
+/// \overload
+template<class RandomAccessRange, class Generator>
+inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
+    return rng;
+}
+
+/// \overload
+template<class RandomAccessRange, class Generator>
+inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
+    return rng;
+}
+
+    } // namespace range
+    using range::random_shuffle;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/remove.hpp

@@ -18,53 +18,57 @@
 
 namespace boost
 {
-    /// \brief template function remove
+    namespace range
-    ///
-    /// range-based version of the remove std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    template< class ForwardRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-    remove(ForwardRange& rng, const Value& val)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-		return std::remove(boost::begin(rng),boost::end(rng),val); 
-    }
 
-    /// \overload
+/// \brief template function remove
-    template< class ForwardRange, class Value >
+///
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+/// range-based version of the remove std algorithm
-    remove(const ForwardRange& rng, const Value& val)
+///
-    {
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+template< class ForwardRange, class Value >
-		return std::remove(boost::begin(rng),boost::end(rng),val);
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-    }
+remove(ForwardRange& rng, const Value& val)
-
+{
-// range_return overloads
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    
+    return std::remove(boost::begin(rng),boost::end(rng),val);
-    /// \overload
-    template< range_return_value re, class ForwardRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-    remove(ForwardRange& rng, const Value& val)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        
-        return range_return<ForwardRange,re>::pack(
-            std::remove(boost::begin(rng), boost::end(rng), val),
-            rng);
-    }
-
-    /// \overload
-    template< range_return_value re, class ForwardRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
-    remove(const ForwardRange& rng, const Value& val)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-
-        return range_return<const ForwardRange,re>::pack(
-            std::remove(boost::begin(rng), boost::end(rng), val),
-            rng);
-    }
 }
 
+/// \overload
+template< class ForwardRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+remove(const ForwardRange& rng, const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::remove(boost::begin(rng),boost::end(rng),val);
+}
+
+// range_return overloads
+
+/// \overload
+template< range_return_value re, class ForwardRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+remove(ForwardRange& rng, const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return range_return<ForwardRange,re>::pack(
+        std::remove(boost::begin(rng), boost::end(rng), val),
+        rng);
+}
+
+/// \overload
+template< range_return_value re, class ForwardRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+remove(const ForwardRange& rng, const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::pack(
+        std::remove(boost::begin(rng), boost::end(rng), val),
+        rng);
+}
+
+    } // namespace range
+    using range::remove;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/remove_copy.hpp

@@ -17,22 +17,28 @@
 
 namespace boost
 {
-    /// \brief template function remove_copy
+    namespace range
-    ///
-    /// range-based version of the remove_copy std algorithm
-    ///
-    /// \pre SinglePassRange is a model of the SinglePassRangeConcept
-    /// \pre OutputIterator is a model of the OutputIteratorConcept
-    /// \pre Value is a model of the EqualityComparableConcept
-    /// \pre Objects of type Value can be compared for equality with objects of
-    /// InputIterator's value type.
-    template< class SinglePassRange, class OutputIterator, class Value >
-    inline OutputIterator
-    remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val)
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+
-		return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val); 
+/// \brief template function remove_copy
-    }
+///
+/// range-based version of the remove_copy std algorithm
+///
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
+/// \pre OutputIterator is a model of the OutputIteratorConcept
+/// \pre Value is a model of the EqualityComparableConcept
+/// \pre Objects of type Value can be compared for equality with objects of
+/// InputIterator's value type.
+template< class SinglePassRange, class OutputIterator, class Value >
+inline OutputIterator
+remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+    return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val);
 }
 
+    } // namespace range
+    using range::remove_copy;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/remove_if.hpp

@@ -18,53 +18,58 @@
 
 namespace boost
 {
-    /// \brief template function remove_if
+    namespace range
-    ///
-    /// range-based version of the remove_if std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
-    template< class ForwardRange, class UnaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
-    remove_if(ForwardRange& rng, UnaryPredicate pred)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-		return std::remove_if(boost::begin(rng), boost::end(rng), pred);
-    }
 
-    /// \overload
+/// \brief template function remove_if
-    template< class ForwardRange, class UnaryPredicate >
+///
-    inline BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
+/// range-based version of the remove_if std algorithm
-    remove_if(const ForwardRange& rng, UnaryPredicate pred)
+///
-    {
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
-		return std::remove_if(boost::begin(rng),boost::end(rng),pred);
+template< class ForwardRange, class UnaryPredicate >
-    }
+inline BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
+remove_if(ForwardRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return std::remove_if(boost::begin(rng), boost::end(rng), pred);
+}
+
+/// \overload
+template< class ForwardRange, class UnaryPredicate >
+inline BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
+remove_if(const ForwardRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::remove_if(boost::begin(rng),boost::end(rng),pred);
+}
 
 // range_return overloads
 
-    /// \overload
+/// \overload
-    template< range_return_value re, class ForwardRange, class UnaryPredicate >
+template< range_return_value re, class ForwardRange, class UnaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-    remove_if(ForwardRange& rng, UnaryPredicate pred)
+remove_if(ForwardRange& rng, UnaryPredicate pred)
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-        return range_return<ForwardRange,re>::pack(
+    return range_return<ForwardRange,re>::pack(
-            std::remove_if(boost::begin(rng), boost::end(rng), pred),
+        std::remove_if(boost::begin(rng), boost::end(rng), pred),
-            rng);
+        rng);
-    }
-
-    /// \overload
-    template< range_return_value re, class ForwardRange, class UnaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
-    remove_if(const ForwardRange& rng, UnaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return range_return<const ForwardRange,re>::pack(
-            std::remove_if(boost::begin(rng), boost::end(rng), pred),
-            rng);
-    }
-
 }
 
+/// \overload
+template< range_return_value re, class ForwardRange, class UnaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+remove_if(const ForwardRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::pack(
+        std::remove_if(boost::begin(rng), boost::end(rng), pred),
+        rng);
+}
+
+    } // namespace range
+    using range::remove_if;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/replace.hpp

@@ -17,31 +17,37 @@
 
 namespace boost
 {
-    /// \brief template function replace
+    namespace range
-    ///
-    /// range-based version of the replace std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    template< class ForwardRange, class Value >
-    inline ForwardRange&
-    replace(ForwardRange& rng, const Value& what,
-            const Value& with_what)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        std::replace(boost::begin(rng), boost::end(rng), what, with_what);
-        return rng;
-    }
 
-    /// \overload
+/// \brief template function replace
-    template< class ForwardRange, class Value >
+///
-    inline const ForwardRange&
+/// range-based version of the replace std algorithm
-    replace(const ForwardRange& rng, const Value& what,
+///
-            const Value& with_what)
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-    {
+template< class ForwardRange, class Value >
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+inline ForwardRange&
-        std::replace(boost::begin(rng), boost::end(rng), what, with_what);
+replace(ForwardRange& rng, const Value& what,
-        return rng;
+        const Value& with_what)
-    }
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    std::replace(boost::begin(rng), boost::end(rng), what, with_what);
+    return rng;
 }
 
+/// \overload
+template< class ForwardRange, class Value >
+inline const ForwardRange&
+replace(const ForwardRange& rng, const Value& what,
+        const Value& with_what)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    std::replace(boost::begin(rng), boost::end(rng), what, with_what);
+    return rng;
+}
+
+    } // namespace range
+    using range::replace;
+} // namespace boost;
+
 #endif // include guard

include/boost/range/algorithm/replace_copy.hpp

@@ -17,20 +17,26 @@
 
 namespace boost
 {
-    /// \brief template function replace_copy
+    namespace range
-    ///
-    /// range-based version of the replace_copy std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    template< class ForwardRange, class OutputIterator, class Value >
-    inline OutputIterator
-    replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what,
-            const Value& with_what)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
-        return std::replace_copy(boost::begin(rng), boost::end(rng), out_it,
+/// \brief template function replace_copy
-            what, with_what);
+///
-    }
+/// range-based version of the replace_copy std algorithm
+///
+/// \pre ForwardRange is a model of the ForwardRangeConcept
+template< class ForwardRange, class OutputIterator, class Value >
+inline OutputIterator
+replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what,
+        const Value& with_what)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return std::replace_copy(boost::begin(rng), boost::end(rng), out_it,
+        what, with_what);
 }
 
+    } // namespace range
+    using range::replace_copy;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/replace_copy_if.hpp

@@ -17,24 +17,30 @@
 
 namespace boost
 {
-    /// \brief template function replace_copy_if
+    namespace range
-    ///
-    /// range-based version of the replace_copy_if std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    /// \pre Predicate is a model of the PredicateConcept
-    /// \pre Value is convertible to Predicate's argument type
-    /// \pre Value is Assignable
-    /// \pre Value is convertible to a type in OutputIterator's set of value types.
-    template< class ForwardRange, class OutputIterator, class Predicate, class Value >
-    inline OutputIterator
-    replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred,
-            const Value& with_what)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
-        return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it,
+/// \brief template function replace_copy_if
-            pred, with_what);
+///
-    }
+/// range-based version of the replace_copy_if std algorithm
+///
+/// \pre ForwardRange is a model of the ForwardRangeConcept
+/// \pre Predicate is a model of the PredicateConcept
+/// \pre Value is convertible to Predicate's argument type
+/// \pre Value is Assignable
+/// \pre Value is convertible to a type in OutputIterator's set of value types.
+template< class ForwardRange, class OutputIterator, class Predicate, class Value >
+inline OutputIterator
+replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred,
+        const Value& with_what)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it,
+        pred, with_what);
 }
 
+    } // namespace range
+    using range::replace_copy_if;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/replace_if.hpp

@@ -17,33 +17,38 @@
 
 namespace boost
 {
-    /// \brief template function replace_if
+    namespace range
-    ///
-    /// range-based version of the replace_if std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
-    template< class ForwardRange, class UnaryPredicate, class Value >
-    inline ForwardRange&
-        replace_if(ForwardRange& rng, UnaryPredicate pred,
-                   const Value& val)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
-        return rng;
-    }
-
-    /// \overload
-    template< class ForwardRange, class UnaryPredicate, class Value >
-    inline const ForwardRange&
-        replace_if(const ForwardRange& rng, UnaryPredicate pred,
-                   const Value& val)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
-        return rng;
-    }
 
+/// \brief template function replace_if
+///
+/// range-based version of the replace_if std algorithm
+///
+/// \pre ForwardRange is a model of the ForwardRangeConcept
+/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
+template< class ForwardRange, class UnaryPredicate, class Value >
+inline ForwardRange&
+    replace_if(ForwardRange& rng, UnaryPredicate pred,
+               const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
+    return rng;
 }
 
+/// \overload
+template< class ForwardRange, class UnaryPredicate, class Value >
+inline const ForwardRange&
+    replace_if(const ForwardRange& rng, UnaryPredicate pred,
+               const Value& val)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
+    return rng;
+}
+
+    } // namespace range
+    using range::replace_if;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/reverse.hpp

@@ -18,27 +18,33 @@
 
 namespace boost
 {
-    /// \brief template function reverse
+    namespace range
-    ///
-    /// range-based version of the reverse std algorithm
-    ///
-    /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
-    template<class BidirectionalRange>
-    inline BidirectionalRange& reverse(BidirectionalRange& rng)
     {
-        boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
-		std::reverse(boost::begin(rng), boost::end(rng));
-        return rng;
-    }
 
-    /// \overload
+/// \brief template function reverse
-    template<class BidirectionalRange>
+///
-    inline const BidirectionalRange& reverse(const BidirectionalRange& rng)
+/// range-based version of the reverse std algorithm
-    {
+///
-        boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
-		std::reverse(boost::begin(rng), boost::end(rng));
+template<class BidirectionalRange>
-        return rng;
+inline BidirectionalRange& reverse(BidirectionalRange& rng)
-    }
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    std::reverse(boost::begin(rng), boost::end(rng));
+    return rng;
 }
 
+/// \overload
+template<class BidirectionalRange>
+inline const BidirectionalRange& reverse(const BidirectionalRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+    std::reverse(boost::begin(rng), boost::end(rng));
+    return rng;
+}
+
+    } // namespace range
+    using range::reverse;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/reverse_copy.hpp

@@ -18,25 +18,31 @@
 
 namespace boost
 {
-    /// \brief template function reverse_copy
+    namespace range
-    ///
-    /// range-based version of the reverse_copy std algorithm
-    ///
-    /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
-    template<typename BidirectionalRange, typename OutputIterator>
-    inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out)
     {
-        BOOST_CONCEPT_ASSERT((BidirectionalRangeConcept<BidirectionalRange>));
-		return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
-    }
 
-    /// \overload
+/// \brief template function reverse_copy
-    template<typename BidirectionalRange, typename OutputIterator>
+///
-    inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out)
+/// range-based version of the reverse_copy std algorithm
-    {
+///
-        BOOST_CONCEPT_ASSERT((BidirectionalRangeConcept<BidirectionalRange>));
+/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
-		return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
+template<typename BidirectionalRange, typename OutputIterator>
-    }
+inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
 }
 
+/// \overload
+template<typename BidirectionalRange, typename OutputIterator>
+inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
+}
+
+    } // namespace range
+    using range::reverse_copy;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/rotate.hpp

@@ -17,30 +17,36 @@
 
 namespace boost
 {
-    /// \brief template function rotate
+    namespace range
-    ///
-    /// range-based version of the rotate std algorithm
-    ///
-    /// \pre Rng meets the requirements for a Forward range
-    template<typename ForwardRange>
-    inline ForwardRange& rotate(ForwardRange& rng,
-        typename range_iterator<ForwardRange>::type middle)
     {
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        std::rotate(boost::begin(rng), middle, boost::end(rng));
-        return rng;
-    }
 
-    /// \overload
+/// \brief template function rotate
-    template<typename ForwardRange>
+///
-    inline const ForwardRange&
+/// range-based version of the rotate std algorithm
-        rotate(const ForwardRange& rng,
+///
-               typename range_iterator<const ForwardRange>::type middle)
+/// \pre Rng meets the requirements for a Forward range
-    {
+template<typename ForwardRange>
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+inline ForwardRange& rotate(ForwardRange& rng,
-        std::rotate(boost::begin(rng), middle, boost::end(rng));
+    typename range_iterator<ForwardRange>::type middle)
-        return rng;
+{
-    }
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    std::rotate(boost::begin(rng), middle, boost::end(rng));
+    return rng;
 }
 
+/// \overload
+template<typename ForwardRange>
+inline const ForwardRange&
+    rotate(const ForwardRange& rng,
+           typename range_iterator<const ForwardRange>::type middle)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    std::rotate(boost::begin(rng), middle, boost::end(rng));
+    return rng;
+}
+
+    } // namespace range
+    using range::rotate;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/rotate_copy.hpp

@@ -18,6 +18,9 @@
 
 namespace boost
 {
+    namespace range
+    {
+
     /// \brief template function rotate
     ///
     /// range-based version of the rotate std algorithm
@@ -30,9 +33,12 @@ namespace boost
         OutputIterator                                      target
         )
     {
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+        BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
         return std::rotate_copy(boost::begin(rng), middle, boost::end(rng), target);
     }
-}
+
+    } // namespace range
+    using range::rotate_copy;
+} // namespace boost
 
 #endif // include guard

include/boost/range/algorithm/search.hpp

@@ -18,114 +18,119 @@
 
 namespace boost
 {
-    /// \brief template function search
+    namespace range
-    ///
-    /// range-based version of the search std algorithm
-    ///
-    /// \pre ForwardRange1 is a model of the ForwardRangeConcept
-    /// \pre ForwardRange2 is a model of the ForwardRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template< class ForwardRange1, class ForwardRange2 >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
-    search(ForwardRange1& rng1, const ForwardRange2& rng2)
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-        return std::search(boost::begin(rng1),boost::end(rng1),
-                           boost::begin(rng2),boost::end(rng2));
-    }
 
-    /// \overload
+/// \brief template function search
-    template< class ForwardRange1, class ForwardRange2 >
+///
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
+/// range-based version of the search std algorithm
-    search(const ForwardRange1& rng1, const ForwardRange2& rng2)
+///
-    {
+/// \pre ForwardRange1 is a model of the ForwardRangeConcept
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+/// \pre ForwardRange2 is a model of the ForwardRangeConcept
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-        return std::search(boost::begin(rng1),boost::end(rng1),
+template< class ForwardRange1, class ForwardRange2 >
-                           boost::begin(rng2),boost::end(rng2));
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
-    }
+search(ForwardRange1& rng1, const ForwardRange2& rng2)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+    return std::search(boost::begin(rng1),boost::end(rng1),
+                       boost::begin(rng2),boost::end(rng2));
+}
 
-    /// \overload
+/// \overload
-    template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
+template< class ForwardRange1, class ForwardRange2 >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
-    search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
+search(const ForwardRange1& rng1, const ForwardRange2& rng2)
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
-        return std::search(boost::begin(rng1),boost::end(rng1),
+    return std::search(boost::begin(rng1),boost::end(rng1),
-                           boost::begin(rng2),boost::end(rng2),pred);
+                       boost::begin(rng2),boost::end(rng2));
-    }
+}
 
-    /// \overload
+/// \overload
-    template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
+template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
-    search(const ForwardRange1& rng1, const ForwardRange2& rng2,
+search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
-            BinaryPredicate pred)
+{
-    {
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+    return std::search(boost::begin(rng1),boost::end(rng1),
-        return std::search(boost::begin(rng1),boost::end(rng1),
+                       boost::begin(rng2),boost::end(rng2),pred);
-                           boost::begin(rng2),boost::end(rng2),pred);
+}
-    }
+
+/// \overload
+template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
+search(const ForwardRange1& rng1, const ForwardRange2& rng2,
+        BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+    return std::search(boost::begin(rng1),boost::end(rng1),
+                       boost::begin(rng2),boost::end(rng2),pred);
+}
 
 // range_return overloads
 
-    /// \overload
+/// \overload
-    template< range_return_value re, class ForwardRange1, class ForwardRange2 >
+template< range_return_value re, class ForwardRange1, class ForwardRange2 >
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
-    search(ForwardRange1& rng1, const ForwardRange2& rng2)
+search(ForwardRange1& rng1, const ForwardRange2& rng2)
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
-        return range_return<ForwardRange1,re>::
+    return range_return<ForwardRange1,re>::
-            pack(std::search(boost::begin(rng1),boost::end(rng1),
+        pack(std::search(boost::begin(rng1),boost::end(rng1),
-                             boost::begin(rng2),boost::end(rng2)),
+                         boost::begin(rng2),boost::end(rng2)),
-                 rng1);
+             rng1);
-    }
-
-    /// \overload
-    template< range_return_value re, class ForwardRange1, class ForwardRange2 >
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
-    search(const ForwardRange1& rng1, const ForwardRange2& rng2)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-        return range_return<const ForwardRange1,re>::
-            pack(std::search(boost::begin(rng1),boost::end(rng1),
-                             boost::begin(rng2),boost::end(rng2)),
-                 rng1);
-    }
-
-    /// \overload
-    template< range_return_value re, class ForwardRange1, class ForwardRange2,
-              class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
-    search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-        return range_return<ForwardRange1,re>::
-            pack(std::search(boost::begin(rng1),boost::end(rng1),
-                             boost::begin(rng2),boost::end(rng2),pred),
-                 rng1);
-    }
-
-    /// \overload
-    template< range_return_value re, class ForwardRange1, class ForwardRange2,
-              class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
-    search(const ForwardRange1& rng1, const ForwardRange2& rng2,
-            BinaryPredicate pred)
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
-        boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
-        return range_return<const ForwardRange1,re>::
-            pack(std::search(boost::begin(rng1),boost::end(rng1),
-                             boost::begin(rng2),boost::end(rng2),pred),
-                 rng1);
-    }
-
 }
 
+/// \overload
+template< range_return_value re, class ForwardRange1, class ForwardRange2 >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
+search(const ForwardRange1& rng1, const ForwardRange2& rng2)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+    return range_return<const ForwardRange1,re>::
+        pack(std::search(boost::begin(rng1),boost::end(rng1),
+                         boost::begin(rng2),boost::end(rng2)),
+             rng1);
+}
+
+/// \overload
+template< range_return_value re, class ForwardRange1, class ForwardRange2,
+          class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+    return range_return<ForwardRange1,re>::
+        pack(std::search(boost::begin(rng1),boost::end(rng1),
+                         boost::begin(rng2),boost::end(rng2),pred),
+             rng1);
+}
+
+/// \overload
+template< range_return_value re, class ForwardRange1, class ForwardRange2,
+          class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
+search(const ForwardRange1& rng1, const ForwardRange2& rng2,
+        BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+    return range_return<const ForwardRange1,re>::
+        pack(std::search(boost::begin(rng1),boost::end(rng1),
+                         boost::begin(rng2),boost::end(rng2),pred),
+             rng1);
+}
+
+    } // namespace range
+    using range::search;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/search_n.hpp

@@ -19,122 +19,127 @@
 
 namespace boost
 {
-    /// \brief template function search
+    namespace range
-    ///
-    /// range-based version of the search std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    /// \pre Integer is an integral type
-    /// \pre Value is a model of the EqualityComparableConcept
-    /// \pre ForwardRange's value type is a model of the EqualityComparableConcept
-    /// \pre Object's of ForwardRange's value type can be compared for equality with Objects of type Value
-    template< typename ForwardRange, typename Integer, typename Value >
-    inline typename range_iterator<ForwardRange>::type
-    search_n(ForwardRange& rng, Integer count, const Value& value)
     {
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        return std::search_n(boost::begin(rng),boost::end(rng), count, value);
-    }
 
-    /// \overload
+/// \brief template function search
-    template< typename ForwardRange, typename Integer, typename Value >
+///
-    inline typename range_iterator<const ForwardRange>::type
+/// range-based version of the search std algorithm
-    search_n(const ForwardRange& rng, Integer count, const Value& value)
+///
-    {
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+/// \pre Integer is an integral type
-        return std::search_n(boost::begin(rng), boost::end(rng), count, value);
+/// \pre Value is a model of the EqualityComparableConcept
-    }
+/// \pre ForwardRange's value type is a model of the EqualityComparableConcept
+/// \pre Object's of ForwardRange's value type can be compared for equality with Objects of type Value
+template< typename ForwardRange, typename Integer, typename Value >
+inline typename range_iterator<ForwardRange>::type
+search_n(ForwardRange& rng, Integer count, const Value& value)
+{
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    return std::search_n(boost::begin(rng),boost::end(rng), count, value);
+}
 
-    /// \overload
+/// \overload
-    template< typename ForwardRange, typename Integer, class Value,
+template< typename ForwardRange, typename Integer, typename Value >
-              typename BinaryPredicate >
+inline typename range_iterator<const ForwardRange>::type
-    inline typename range_iterator<ForwardRange>::type
+search_n(const ForwardRange& rng, Integer count, const Value& value)
-    search_n(ForwardRange& rng, Integer count, const Value& value,
+{
-             BinaryPredicate binary_pred)
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-    {
+    return std::search_n(boost::begin(rng), boost::end(rng), count, value);
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+}
-        BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
-            typename range_value<ForwardRange>::type, const Value&>));
-        return std::search_n(boost::begin(rng), boost::end(rng),
-            count, value, binary_pred);
-	}
 
-    /// \overload
+/// \overload
-    template< typename ForwardRange, typename Integer, typename Value,
+template< typename ForwardRange, typename Integer, class Value,
-              typename BinaryPredicate >
+          typename BinaryPredicate >
-    inline typename range_iterator<const ForwardRange>::type
+inline typename range_iterator<ForwardRange>::type
-    search_n(const ForwardRange& rng, Integer count, const Value& value,
+search_n(ForwardRange& rng, Integer count, const Value& value,
-             BinaryPredicate binary_pred)
+         BinaryPredicate binary_pred)
-    {
+{
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+    BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
-            typename range_value<const ForwardRange>::type, const Value&>));
+        typename range_value<ForwardRange>::type, const Value&>));
-        return std::search_n(boost::begin(rng), boost::end(rng),
+    return std::search_n(boost::begin(rng), boost::end(rng),
-            count, value, binary_pred);
+        count, value, binary_pred);
-    }
+}
+
+/// \overload
+template< typename ForwardRange, typename Integer, typename Value,
+          typename BinaryPredicate >
+inline typename range_iterator<const ForwardRange>::type
+search_n(const ForwardRange& rng, Integer count, const Value& value,
+         BinaryPredicate binary_pred)
+{
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+        typename range_value<const ForwardRange>::type, const Value&>));
+    return std::search_n(boost::begin(rng), boost::end(rng),
+        count, value, binary_pred);
+}
 
 // range_return overloads
 
-    /// \overload
+/// \overload
-    template< range_return_value re, typename ForwardRange, typename Integer,
+template< range_return_value re, typename ForwardRange, typename Integer,
-              typename Value >
+          typename Value >
-    inline typename range_return<ForwardRange,re>::type
+inline typename range_return<ForwardRange,re>::type
-    search_n(ForwardRange& rng, Integer count, const Value& value)
+search_n(ForwardRange& rng, Integer count, const Value& value)
-    {
+{
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        return range_return<ForwardRange,re>::
+    return range_return<ForwardRange,re>::
-            pack(std::search_n(boost::begin(rng),boost::end(rng),
+        pack(std::search_n(boost::begin(rng),boost::end(rng),
-                               count, value),
+                           count, value),
-                 rng);
+             rng);
-    }
-
-    /// \overload
-    template< range_return_value re, typename ForwardRange, typename Integer,
-              class Value >
-    inline typename range_return<const ForwardRange,re>::type
-    search_n(const ForwardRange& rng, Integer count, const Value& value)
-    {
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        return range_return<const ForwardRange,re>::
-            pack(std::search_n(boost::begin(rng), boost::end(rng),
-                               count, value),
-                 rng);
-    }
-
-    /// \overload
-    template< range_return_value re, typename ForwardRange, typename Integer,
-              typename Value, typename BinaryPredicate >
-    inline typename range_return<ForwardRange,re>::type
-    search_n(ForwardRange& rng, Integer count, const Value& value,
-             BinaryPredicate pred)
-    {
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
-            typename range_value<ForwardRange>::type,
-            const Value&>));
-        return range_return<ForwardRange,re>::
-            pack(std::search_n(boost::begin(rng), boost::end(rng),
-                               count, value, pred),
-                 rng);
-    }
-
-    /// \overload
-    template< range_return_value re, typename ForwardRange, typename Integer,
-              typename Value, typename BinaryPredicate >
-    inline typename range_return<const ForwardRange,re>::type
-    search_n(const ForwardRange& rng, Integer count, const Value& value,
-             BinaryPredicate pred)
-    {
-        BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-        BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
-            typename range_value<const ForwardRange>::type,
-            const Value&>));
-        return range_return<const ForwardRange,re>::
-            pack(std::search_n(boost::begin(rng), boost::end(rng),
-                               count, value, pred),
-                 rng);
-    }
-
 }
 
+/// \overload
+template< range_return_value re, typename ForwardRange, typename Integer,
+          class Value >
+inline typename range_return<const ForwardRange,re>::type
+search_n(const ForwardRange& rng, Integer count, const Value& value)
+{
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    return range_return<const ForwardRange,re>::
+        pack(std::search_n(boost::begin(rng), boost::end(rng),
+                           count, value),
+             rng);
+}
+
+/// \overload
+template< range_return_value re, typename ForwardRange, typename Integer,
+          typename Value, typename BinaryPredicate >
+inline typename range_return<ForwardRange,re>::type
+search_n(ForwardRange& rng, Integer count, const Value& value,
+         BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+        typename range_value<ForwardRange>::type,
+        const Value&>));
+    return range_return<ForwardRange,re>::
+        pack(std::search_n(boost::begin(rng), boost::end(rng),
+                           count, value, pred),
+             rng);
+}
+
+/// \overload
+template< range_return_value re, typename ForwardRange, typename Integer,
+          typename Value, typename BinaryPredicate >
+inline typename range_return<const ForwardRange,re>::type
+search_n(const ForwardRange& rng, Integer count, const Value& value,
+         BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+        typename range_value<const ForwardRange>::type,
+        const Value&>));
+    return range_return<const ForwardRange,re>::
+        pack(std::search_n(boost::begin(rng), boost::end(rng),
+                           count, value, pred),
+             rng);
+}
+
+    } // namespace range
+    using range::search_n;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/set_algorithm.hpp

@@ -17,172 +17,182 @@
 
 namespace boost
 {
-    /// \brief template function includes
+    namespace range
-    ///
-    /// range-based version of the includes std algorithm
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class SinglePassRange1, class SinglePassRange2>
-    inline bool includes(const SinglePassRange1& rng1,
-                         const SinglePassRange2& rng2)
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-        return std::includes(boost::begin(rng1),boost::end(rng1),
-                             boost::begin(rng2),boost::end(rng2));
-    }
 
-    /// \overload
+/// \brief template function includes
-    template<class SinglePassRange1, class SinglePassRange2,
+///
-             class BinaryPredicate>
+/// range-based version of the includes std algorithm
-    inline bool includes(const SinglePassRange1& rng1,
+///
-                         const SinglePassRange2& rng2,
+/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-                         BinaryPredicate         pred)
+/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    {
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+template<class SinglePassRange1, class SinglePassRange2>
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+inline bool includes(const SinglePassRange1& rng1,
-        return std::includes(boost::begin(rng1), boost::end(rng1),
+                     const SinglePassRange2& rng2)
-                             boost::begin(rng2), boost::end(rng2), pred);
+{
-    }
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
-    /// \brief template function set_union
+    return std::includes(boost::begin(rng1),boost::end(rng1),
-    ///
+                         boost::begin(rng2),boost::end(rng2));
-    /// range-based version of the set_union std algorithm
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class SinglePassRange1, class SinglePassRange2,
-             class OutputIterator>
-    inline OutputIterator set_union(const SinglePassRange1& rng1,
-                                    const SinglePassRange2& rng2,
-                                    OutputIterator          out)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-        return std::set_union(boost::begin(rng1), boost::end(rng1),
-                              boost::begin(rng2), boost::end(rng2), out);
-    }
-
-    /// \overload
-    template<class SinglePassRange1, class SinglePassRange2,
-             class OutputIterator, class BinaryPredicate>
-    inline OutputIterator set_union(const SinglePassRange1& rng1,
-                                    const SinglePassRange2& rng2,
-                                    OutputIterator          out,
-                                    BinaryPredicate         pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-        return std::set_union(boost::begin(rng1), boost::end(rng1),
-                              boost::begin(rng2), boost::end(rng2), out, pred);
-    }
-
-    /// \brief template function set_intersection
-    ///
-    /// range-based version of the set_intersection std algorithm
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class SinglePassRange1, class SinglePassRange2,
-             class OutputIterator>
-    inline OutputIterator set_intersection(const SinglePassRange1& rng1,
-                                           const SinglePassRange2& rng2,
-                                           OutputIterator          out)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-        return std::set_intersection(boost::begin(rng1), boost::end(rng1),
-                                     boost::begin(rng2), boost::end(rng2), out);
-    }
-
-    /// \overload
-    template<class SinglePassRange1, class SinglePassRange2,
-             class OutputIterator, class BinaryPredicate>
-    inline OutputIterator set_intersection(const SinglePassRange1& rng1,
-                                           const SinglePassRange2& rng2,
-                                           OutputIterator          out,
-                                           BinaryPredicate         pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-        return std::set_intersection(boost::begin(rng1), boost::end(rng1),
-                                     boost::begin(rng2), boost::end(rng2),
-                                     out, pred);
-    }
-
-    /// \brief template function set_difference
-    ///
-    /// range-based version of the set_difference std algorithm
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class SinglePassRange1, class SinglePassRange2,
-             class OutputIterator>
-    inline OutputIterator set_difference(const SinglePassRange1& rng1,
-                                         const SinglePassRange2& rng2,
-                                         OutputIterator out)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-        return std::set_difference(boost::begin(rng1), boost::end(rng1),
-                                   boost::begin(rng2), boost::end(rng2), out);
-    }
-
-    /// \overload
-    template<class SinglePassRange1, class SinglePassRange2,
-             class OutputIterator, class BinaryPredicate>
-    inline OutputIterator set_difference(const SinglePassRange1& rng1,
-                                         const SinglePassRange2& rng2,
-                                         OutputIterator          out,
-                                         BinaryPredicate         pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-        return std::set_difference(
-            boost::begin(rng1), boost::end(rng1),
-            boost::begin(rng2), boost::end(rng2), out, pred);
-    }
-
-    /// \brief template function set_symmetric_difference
-    ///
-    /// range-based version of the set_symmetric_difference std algorithm
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class SinglePassRange1, class SinglePassRange2,
-             class OutputIterator>
-    inline OutputIterator
-    set_symmetric_difference(const SinglePassRange1& rng1,
-                             const SinglePassRange2& rng2,
-                             OutputIterator          out)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-        return std::set_symmetric_difference(boost::begin(rng1), boost::end(rng1),
-                                             boost::begin(rng2), boost::end(rng2), out);
-    }
-
-    /// \overload
-    template<class SinglePassRange1, class SinglePassRange2,
-             class OutputIterator, class BinaryPredicate>
-    inline OutputIterator
-    set_symmetric_difference(const SinglePassRange1& rng1,
-                             const SinglePassRange2& rng2,
-                             OutputIterator          out,
-                             BinaryPredicate         pred)
-    {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
-        return std::set_symmetric_difference(
-            boost::begin(rng1), boost::end(rng1),
-            boost::begin(rng2), boost::end(rng2), out, pred);
-    }
 }
 
+/// \overload
+template<class SinglePassRange1, class SinglePassRange2,
+         class BinaryPredicate>
+inline bool includes(const SinglePassRange1& rng1,
+                     const SinglePassRange2& rng2,
+                     BinaryPredicate         pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::includes(boost::begin(rng1), boost::end(rng1),
+                         boost::begin(rng2), boost::end(rng2), pred);
+}
+
+/// \brief template function set_union
+///
+/// range-based version of the set_union std algorithm
+///
+/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+template<class SinglePassRange1, class SinglePassRange2,
+         class OutputIterator>
+inline OutputIterator set_union(const SinglePassRange1& rng1,
+                                const SinglePassRange2& rng2,
+                                OutputIterator          out)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::set_union(boost::begin(rng1), boost::end(rng1),
+                          boost::begin(rng2), boost::end(rng2), out);
+}
+
+/// \overload
+template<class SinglePassRange1, class SinglePassRange2,
+         class OutputIterator, class BinaryPredicate>
+inline OutputIterator set_union(const SinglePassRange1& rng1,
+                                const SinglePassRange2& rng2,
+                                OutputIterator          out,
+                                BinaryPredicate         pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::set_union(boost::begin(rng1), boost::end(rng1),
+                          boost::begin(rng2), boost::end(rng2), out, pred);
+}
+
+/// \brief template function set_intersection
+///
+/// range-based version of the set_intersection std algorithm
+///
+/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+template<class SinglePassRange1, class SinglePassRange2,
+         class OutputIterator>
+inline OutputIterator set_intersection(const SinglePassRange1& rng1,
+                                       const SinglePassRange2& rng2,
+                                       OutputIterator          out)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::set_intersection(boost::begin(rng1), boost::end(rng1),
+                                 boost::begin(rng2), boost::end(rng2), out);
+}
+
+/// \overload
+template<class SinglePassRange1, class SinglePassRange2,
+         class OutputIterator, class BinaryPredicate>
+inline OutputIterator set_intersection(const SinglePassRange1& rng1,
+                                       const SinglePassRange2& rng2,
+                                       OutputIterator          out,
+                                       BinaryPredicate         pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::set_intersection(boost::begin(rng1), boost::end(rng1),
+                                 boost::begin(rng2), boost::end(rng2),
+                                 out, pred);
+}
+
+/// \brief template function set_difference
+///
+/// range-based version of the set_difference std algorithm
+///
+/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+template<class SinglePassRange1, class SinglePassRange2,
+         class OutputIterator>
+inline OutputIterator set_difference(const SinglePassRange1& rng1,
+                                     const SinglePassRange2& rng2,
+                                     OutputIterator out)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::set_difference(boost::begin(rng1), boost::end(rng1),
+                               boost::begin(rng2), boost::end(rng2), out);
+}
+
+/// \overload
+template<class SinglePassRange1, class SinglePassRange2,
+         class OutputIterator, class BinaryPredicate>
+inline OutputIterator set_difference(const SinglePassRange1& rng1,
+                                     const SinglePassRange2& rng2,
+                                     OutputIterator          out,
+                                     BinaryPredicate         pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::set_difference(
+        boost::begin(rng1), boost::end(rng1),
+        boost::begin(rng2), boost::end(rng2), out, pred);
+}
+
+/// \brief template function set_symmetric_difference
+///
+/// range-based version of the set_symmetric_difference std algorithm
+///
+/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+template<class SinglePassRange1, class SinglePassRange2,
+         class OutputIterator>
+inline OutputIterator
+set_symmetric_difference(const SinglePassRange1& rng1,
+                         const SinglePassRange2& rng2,
+                         OutputIterator          out)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::set_symmetric_difference(boost::begin(rng1), boost::end(rng1),
+                                         boost::begin(rng2), boost::end(rng2), out);
+}
+
+/// \overload
+template<class SinglePassRange1, class SinglePassRange2,
+         class OutputIterator, class BinaryPredicate>
+inline OutputIterator
+set_symmetric_difference(const SinglePassRange1& rng1,
+                         const SinglePassRange2& rng2,
+                         OutputIterator          out,
+                         BinaryPredicate         pred)
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+    return std::set_symmetric_difference(
+        boost::begin(rng1), boost::end(rng1),
+        boost::begin(rng2), boost::end(rng2), out, pred);
+}
+
+    } // namespace range
+    using range::includes;
+    using range::set_union;
+    using range::set_intersection;
+    using range::set_difference;
+    using range::set_symmetric_difference;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/sort.hpp

@@ -17,47 +17,52 @@
 
 namespace boost
 {
-    /// \brief template function sort
+    namespace range
-    ///
-    /// range-based version of the sort std algorithm
-    ///
-    /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class RandomAccessRange>
-    inline RandomAccessRange& sort(RandomAccessRange& rng)
     {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-         std::sort(boost::begin(rng), boost::end(rng));
 
-         return rng;
+/// \brief template function sort
-    }
+///
-
+/// range-based version of the sort std algorithm
-    /// \overload
+///
-    template<class RandomAccessRange>
+/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-    inline const RandomAccessRange& sort(const RandomAccessRange& rng)
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    {
+template<class RandomAccessRange>
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+inline RandomAccessRange& sort(RandomAccessRange& rng)
-        std::sort(boost::begin(rng),boost::end(rng));
+{
-        return rng;
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
-    }
+    std::sort(boost::begin(rng), boost::end(rng));
-
+    return rng;
-    /// \overload
-    template<class RandomAccessRange, class BinaryPredicate>
-    inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::sort(boost::begin(rng), boost::end(rng), pred);
-        return rng;
-	}
-
-    /// \overload
-    template<class RandomAccessRange, class BinaryPredicate>
-    inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::sort(boost::begin(rng), boost::end(rng), pred);
-        return rng;
-    }
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline const RandomAccessRange& sort(const RandomAccessRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::sort(boost::begin(rng),boost::end(rng));
+    return rng;
+}
+
+/// \overload
+template<class RandomAccessRange, class BinaryPredicate>
+inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::sort(boost::begin(rng), boost::end(rng), pred);
+    return rng;
+}
+
+/// \overload
+template<class RandomAccessRange, class BinaryPredicate>
+inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::sort(boost::begin(rng), boost::end(rng), pred);
+    return rng;
+}
+
+    } // namespace range
+    using range::sort;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/stable_partition.hpp

@@ -18,51 +18,56 @@
 
 namespace boost
 {
-    /// \brief template function stable_partition
+    namespace range
-    ///
-    /// range-based version of the stable_partition std algorithm
-    ///
-    /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
-    /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
-    template<class BidirectionalRange, class UnaryPredicate>
-    inline BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type
-    stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
     {
-        boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
-        return std::stable_partition(boost::begin(rng), boost::end(rng), pred);
-    }
-
-    /// \overload
-    template<class BidirectionalRange, class UnaryPredicate>
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const BidirectionalRange>::type
-    stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
-    {
-        boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
-        return std::stable_partition(boost::begin(rng),boost::end(rng),pred);
-    }
-
-// range_return overloads
-    template<range_return_value re, class BidirectionalRange, class UnaryPredicate>
-    inline BOOST_DEDUCED_TYPENAME range_return<BidirectionalRange,re>::type
-    stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
-    {
-        boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
-        return range_return<BidirectionalRange,re>::pack(
-            std::stable_partition(boost::begin(rng), boost::end(rng), pred),
-            rng);
-    }
-
-    /// \overload
-    template<range_return_value re, class BidirectionalRange, class UnaryPredicate>
-    inline BOOST_DEDUCED_TYPENAME range_return<const BidirectionalRange,re>::type
-    stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
-    {
-        boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
-        return range_return<const BidirectionalRange,re>::pack(
-            std::stable_partition(boost::begin(rng),boost::end(rng),pred),
-            rng);
-    }
 
+/// \brief template function stable_partition
+///
+/// range-based version of the stable_partition std algorithm
+///
+/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
+/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
+template<class BidirectionalRange, class UnaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type
+stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    return std::stable_partition(boost::begin(rng), boost::end(rng), pred);
 }
 
+/// \overload
+template<class BidirectionalRange, class UnaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_iterator<const BidirectionalRange>::type
+stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+    return std::stable_partition(boost::begin(rng),boost::end(rng),pred);
+}
+
+// range_return overloads
+template<range_return_value re, class BidirectionalRange, class UnaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_return<BidirectionalRange,re>::type
+stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    return range_return<BidirectionalRange,re>::pack(
+        std::stable_partition(boost::begin(rng), boost::end(rng), pred),
+        rng);
+}
+
+/// \overload
+template<range_return_value re, class BidirectionalRange, class UnaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_return<const BidirectionalRange,re>::type
+stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
+{
+    BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+    return range_return<const BidirectionalRange,re>::pack(
+        std::stable_partition(boost::begin(rng),boost::end(rng),pred),
+        rng);
+}
+
+    } // namespace range
+    using range::stable_partition;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/stable_sort.hpp

@@ -17,46 +17,52 @@
 
 namespace boost
 {
-    /// \brief template function stable_sort
+    namespace range
-    ///
-    /// range-based version of the stable_sort std algorithm
-    ///
-    /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-    template<class RandomAccessRange>
-    inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
     {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::stable_sort(boost::begin(rng), boost::end(rng));
-        return rng;
-    }
 
-    /// \overload
+/// \brief template function stable_sort
-    template<class RandomAccessRange>
+///
-    inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
+/// range-based version of the stable_sort std algorithm
-    {
+///
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
-        std::stable_sort(boost::begin(rng), boost::end(rng));
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-        return rng;
+template<class RandomAccessRange>
-    }
+inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
-
+{
-    /// \overload
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
-    template<class RandomAccessRange, class BinaryPredicate>
+    std::stable_sort(boost::begin(rng), boost::end(rng));
-    inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred)
+    return rng;
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
-        return rng;
-    }
-
-    /// \overload
-    template<class RandomAccessRange, class BinaryPredicate>
-    inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred)
-    {
-        boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
-        std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
-        return rng;
-    }
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::stable_sort(boost::begin(rng), boost::end(rng));
+    return rng;
+}
+
+/// \overload
+template<class RandomAccessRange, class BinaryPredicate>
+inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
+    std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
+    return rng;
+}
+
+/// \overload
+template<class RandomAccessRange, class BinaryPredicate>
+inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred)
+{
+    BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
+    return rng;
+}
+
+    } // namespace range
+    using range::stable_sort;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/swap_ranges.hpp

@@ -57,25 +57,31 @@ namespace boost
         }
     } // namespace range_detail
 
-    /// \brief template function swap_ranges
+    namespace range
-    ///
-    /// range-based version of the swap_ranges std algorithm
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    template< typename SinglePassRange1, typename SinglePassRange2 >
-    inline SinglePassRange2&
-    swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2)
     {
-        BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange1>));
-        BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange2>));
 
-        boost::range_detail::swap_ranges_impl(
+/// \brief template function swap_ranges
-            boost::begin(range1), boost::end(range1),
+///
-            boost::begin(range2), boost::end(range2));
+/// range-based version of the swap_ranges std algorithm
+///
+/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+template< typename SinglePassRange1, typename SinglePassRange2 >
+inline SinglePassRange2&
+swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2)
+{
+    BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange1>));
+    BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange2>));
 
-        return range2;
+    boost::range_detail::swap_ranges_impl(
-    }
+        boost::begin(range1), boost::end(range1),
+        boost::begin(range2), boost::end(range2));
+
+    return range2;
 }
 
+    } // namespace range
+    using range::swap_ranges;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/transform.hpp

@@ -18,25 +18,31 @@
 
 namespace boost
 {
-    /// \brief template function transform
+    namespace range
-    ///
-    /// range-based version of the transform std algorithm
-    ///
-    /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
-    /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-    /// \pre OutputIterator is a model of the OutputIteratorConcept
-    /// \pre UnaryOperation is a model of the UnaryFunctionConcept
-    /// \pre BinaryOperation is a model of the BinaryFunctionConcept
-    template< class SinglePassRange1,
-              class OutputIterator,
-              class UnaryOperation >
-    inline OutputIterator
-    transform(const SinglePassRange1& rng,
-              OutputIterator          out,
-              UnaryOperation          fun)
     {
-        return std::transform(boost::begin(rng),boost::end(rng),out,fun);
+
-    }
+        /// \brief template function transform
+        ///
+        /// range-based version of the transform std algorithm
+        ///
+        /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+        /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+        /// \pre OutputIterator is a model of the OutputIteratorConcept
+        /// \pre UnaryOperation is a model of the UnaryFunctionConcept
+        /// \pre BinaryOperation is a model of the BinaryFunctionConcept
+        template< class SinglePassRange1,
+                  class OutputIterator,
+                  class UnaryOperation >
+        inline OutputIterator
+        transform(const SinglePassRange1& rng,
+                  OutputIterator          out,
+                  UnaryOperation          fun)
+        {
+            BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+            return std::transform(boost::begin(rng),boost::end(rng),out,fun);
+        }
+
+    } // namespace range
 
     namespace range_detail
     {
@@ -62,24 +68,30 @@ namespace boost
         }
     }
 
-    /// \overload
+    namespace range
-    template< class SinglePassRange1,
-              class SinglePassRange2,
-              class OutputIterator,
-              class BinaryOperation >
-    inline OutputIterator
-    transform(const SinglePassRange1& rng1,
-              const SinglePassRange2& rng2,
-              OutputIterator          out,
-              BinaryOperation         fun)
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+        /// \overload
-        return range_detail::transform_impl(
+        template< class SinglePassRange1,
-                    boost::begin(rng1), boost::end(rng1),
+                  class SinglePassRange2,
-                    boost::begin(rng2), boost::end(rng2),
+                  class OutputIterator,
-                    out, fun);
+                  class BinaryOperation >
-    }
+        inline OutputIterator
-}
+        transform(const SinglePassRange1& rng1,
+                  const SinglePassRange2& rng2,
+                  OutputIterator          out,
+                  BinaryOperation         fun)
+        {
+            BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+            BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+            return range_detail::transform_impl(
+                        boost::begin(rng1), boost::end(rng1),
+                        boost::begin(rng2), boost::end(rng2),
+                        out, fun);
+        }
+
+    } // namespace range
+    using range::transform;
+} // namespace boost
 
 #endif // include guard

include/boost/range/algorithm/unique.hpp

@@ -18,84 +18,90 @@
 
 namespace boost
 {
-    /// \brief template function unique
+    namespace range
-    ///
+    {
-    /// range-based version of the unique std algorithm
-    ///
-    /// \pre Rng meets the requirements for a Forward range
-	template< range_return_value re, class ForwardRange >
-	inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-	unique( ForwardRange& rng )
-	{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-		return range_return<ForwardRange,re>::
-            pack( std::unique( boost::begin(rng), 
-							   boost::end(rng)), rng );
-	}
 
-    /// \overload
+/// \brief template function unique
-	template< range_return_value re, class ForwardRange >
+///
-	inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+/// range-based version of the unique std algorithm
-    unique( const ForwardRange& rng )
+///
-	{
+/// \pre Rng meets the requirements for a Forward range
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+template< range_return_value re, class ForwardRange >
-		return range_return<const ForwardRange,re>::
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-            pack( std::unique( boost::begin(rng), 
+unique( ForwardRange& rng )
-							   boost::end(rng)), rng );
+{
-	}
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    /// \overload
+    return range_return<ForwardRange,re>::
-    template< range_return_value re, class ForwardRange, class BinaryPredicate >
+        pack( std::unique( boost::begin(rng),
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+                           boost::end(rng)), rng );
-    unique( ForwardRange& rng, BinaryPredicate pred )
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return range_return<ForwardRange,re>::
-            pack(std::unique(boost::begin(rng), boost::end(rng), pred),
-                 rng);
-    }
-    /// \overload
-    template< range_return_value re, class ForwardRange, class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
-    unique( const ForwardRange& rng, BinaryPredicate pred )
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return range_return<const ForwardRange,re>::
-            pack(std::unique(boost::begin(rng), boost::end(rng), pred),
-                 rng);
-    }
-
-    /// \overload
-    template< class ForwardRange >
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
-	unique( ForwardRange& rng )
-	{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return boost::unique<return_begin_found>(rng);
-	}
-    /// \overload
-	template< class ForwardRange >
-	inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type
-	unique( const ForwardRange& rng )
-	{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return boost::unique<return_begin_found>(rng);
-	}
-    /// \overload
-    template< class ForwardRange, class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
-    unique( ForwardRange& rng, BinaryPredicate pred )
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return boost::unique<return_begin_found>(rng);
-    }
-    /// \overload
-    template< class ForwardRange, class BinaryPredicate >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
-    unique( const ForwardRange& rng, BinaryPredicate pred )
-    {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
-        return boost::unique<return_begin_found>(rng, pred);
-    }
 }
 
+/// \overload
+template< range_return_value re, class ForwardRange >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+unique( const ForwardRange& rng )
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::
+        pack( std::unique( boost::begin(rng),
+                           boost::end(rng)), rng );
+}
+/// \overload
+template< range_return_value re, class ForwardRange, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+unique( ForwardRange& rng, BinaryPredicate pred )
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return range_return<ForwardRange,re>::
+        pack(std::unique(boost::begin(rng), boost::end(rng), pred),
+             rng);
+}
+/// \overload
+template< range_return_value re, class ForwardRange, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+unique( const ForwardRange& rng, BinaryPredicate pred )
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::
+        pack(std::unique(boost::begin(rng), boost::end(rng), pred),
+             rng);
+}
+
+/// \overload
+template< class ForwardRange >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
+unique( ForwardRange& rng )
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return ::boost::range::unique<return_begin_found>(rng);
+}
+/// \overload
+template< class ForwardRange >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type
+unique( const ForwardRange& rng )
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return ::boost::range::unique<return_begin_found>(rng);
+}
+/// \overload
+template< class ForwardRange, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
+unique( ForwardRange& rng, BinaryPredicate pred )
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    return ::boost::range::unique<return_begin_found>(rng);
+}
+/// \overload
+template< class ForwardRange, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+unique( const ForwardRange& rng, BinaryPredicate pred )
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return ::boost::range::unique<return_begin_found>(rng, pred);
+}
+
+    } // namespace range
+    using range::unique;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/unique_copy.hpp

@@ -17,29 +17,35 @@
 
 namespace boost
 {
-    /// \brief template function unique_copy
+    namespace range
-    ///
-    /// range-based version of the unique_copy std algorithm
-    ///
-    /// \pre SinglePassRange is a model of the SinglePassRangeConcept
-    /// \pre OutputIterator is a model of the OutputIteratorConcept
-    /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-	template< class SinglePassRange, class OutputIterator >
-	inline OutputIterator
-    unique_copy( const SinglePassRange& rng, OutputIterator out_it )
-	{
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
-        return std::unique_copy(boost::begin(rng), boost::end(rng), out_it);
-	}
-    /// \overload
-    template< class SinglePassRange, class OutputIterator, class BinaryPredicate >
-    inline OutputIterator
-    unique_copy( const SinglePassRange& rng, OutputIterator out_it,
-                 BinaryPredicate pred )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+
-        return std::unique_copy(boost::begin(rng), boost::end(rng), out_it, pred);
+/// \brief template function unique_copy
-    }
+///
+/// range-based version of the unique_copy std algorithm
+///
+/// \pre SinglePassRange is a model of the SinglePassRangeConcept
+/// \pre OutputIterator is a model of the OutputIteratorConcept
+/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+template< class SinglePassRange, class OutputIterator >
+inline OutputIterator
+unique_copy( const SinglePassRange& rng, OutputIterator out_it )
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return std::unique_copy(boost::begin(rng), boost::end(rng), out_it);
+}
+/// \overload
+template< class SinglePassRange, class OutputIterator, class BinaryPredicate >
+inline OutputIterator
+unique_copy( const SinglePassRange& rng, OutputIterator out_it,
+             BinaryPredicate pred )
+{
+    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return std::unique_copy(boost::begin(rng), boost::end(rng), out_it, pred);
 }
 
+    } // namespace range
+    using range::unique_copy;
+} // namespace boost
+
 #endif // include guard

include/boost/range/algorithm/upper_bound.hpp

@@ -18,84 +18,90 @@
 
 namespace boost
 {
-    /// \brief template function upper_bound
+    namespace range
-    ///
-    /// range-based version of the upper_bound std algorithm
-    ///
-    /// \pre ForwardRange is a model of the ForwardRangeConcept
-    template< class ForwardRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-    upper_bound( ForwardRange& rng, Value val )
     {
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
-        return std::upper_bound(boost::begin(rng), boost::end(rng), val);
+/// \brief template function upper_bound
-    }
+///
-    /// \overload
+/// range-based version of the upper_bound std algorithm
-    template< class ForwardRange, class Value >
+///
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+/// \pre ForwardRange is a model of the ForwardRangeConcept
-    upper_bound( const ForwardRange& rng, Value val )
+template< class ForwardRange, class Value >
-    {
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+upper_bound( ForwardRange& rng, Value val )
-        return std::upper_bound(boost::begin(rng), boost::end(rng), val);
+{
-    }
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    /// \overload
+    return std::upper_bound(boost::begin(rng), boost::end(rng), val);
-    template< class ForwardRange, class Value, class SortPredicate >
+}
-    inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+/// \overload
-    upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
+template< class ForwardRange, class Value >
-    {
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+upper_bound( const ForwardRange& rng, Value val )
-        return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
+{
-    }
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    /// \overload
+    return std::upper_bound(boost::begin(rng), boost::end(rng), val);
-    template< class ForwardRange, class Value, class SortPredicate >
+}
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+/// \overload
-    upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+template< class ForwardRange, class Value, class SortPredicate >
-    {
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
-        return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
+{
-    }
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    /// \overload
+    return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
-    template< range_return_value re, class ForwardRange, class Value >
+}
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+/// \overload
-    upper_bound( ForwardRange& rng, Value val )
+template< class ForwardRange, class Value, class SortPredicate >
-    {
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
-        return range_return<ForwardRange,re>::
+{
-            pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-                 rng);
+    return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
-    }
+}
-    /// \overload
+/// \overload
-    template< range_return_value re, class ForwardRange, class Value >
+template< range_return_value re, class ForwardRange, class Value >
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-    upper_bound( const ForwardRange& rng, Value val )
+upper_bound( ForwardRange& rng, Value val )
-    {
+{
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-        return range_return<const ForwardRange,re>::
+    return range_return<ForwardRange,re>::
-            pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
+        pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
-                 rng);
+             rng);
-    }
+}
-    /// \overload
+/// \overload
-    template< range_return_value re, class ForwardRange, class Value,
+template< range_return_value re, class ForwardRange, class Value >
-              class SortPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
-    inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+upper_bound( const ForwardRange& rng, Value val )
-    upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
+{
-    {
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    return range_return<const ForwardRange,re>::
-        return range_return<ForwardRange,re>::
+        pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
-            pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
+             rng);
-                 rng);
+}
-    }
+/// \overload
-    /// \overload
+template< range_return_value re, class ForwardRange, class Value,
-    template< range_return_value re, class ForwardRange, class Value,
+          class SortPredicate >
-              class SortPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
-    inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
-    upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+{
-    {
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-        boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+    return range_return<ForwardRange,re>::
-        return range_return<const ForwardRange,re>::
+        pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
-            pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
+             rng);
-                 rng);
+}
-    }
+/// \overload
+template< range_return_value re, class ForwardRange, class Value,
+          class SortPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::
+        pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
+             rng);
 }
 
+    } // namespace range
+    using range::upper_bound;
+} // namespace boost
+
 #endif // include guard