From cf63ba0dc93283611a35dca5ae2dc9eb630d3ad3 Mon Sep 17 00:00:00 2001
From: Neil Groves <neil@grovescomputing.com>
Date: Wed, 14 Apr 2010 22:16:11 +0000
Subject: [PATCH] Boost.Range removed redundant overloads, increased compiler
 support, and made return types consistent.

[SVN r61281]
---
 .../boost/range/algorithm/adjacent_find.hpp   | 65 ++-----------
 include/boost/range/algorithm/count.hpp       |  9 --
 include/boost/range/algorithm/count_if.hpp    |  9 --
 include/boost/range/algorithm/equal_range.hpp | 24 -----
 include/boost/range/algorithm/for_each.hpp    |  8 --
 include/boost/range/algorithm/generate.hpp    |  9 --
 .../boost/range/algorithm/heap_algorithm.hpp  | 73 +--------------
 .../boost/range/algorithm/inplace_merge.hpp   | 21 -----
 include/boost/range/algorithm/max_element.hpp | 40 --------
 include/boost/range/algorithm/min_element.hpp | 40 --------
 include/boost/range/algorithm/mismatch.hpp    | 91 -------------------
 include/boost/range/algorithm/nth_element.hpp | 21 -----
 .../boost/range/algorithm/partial_sort.hpp    | 21 -----
 .../range/algorithm/partial_sort_copy.hpp     | 16 +---
 include/boost/range/algorithm/partition.hpp   | 20 ----
 include/boost/range/algorithm/permutation.hpp | 36 --------
 .../boost/range/algorithm/random_shuffle.hpp  | 18 ----
 include/boost/range/algorithm/remove.hpp      | 20 ----
 include/boost/range/algorithm/remove_if.hpp   | 20 ----
 include/boost/range/algorithm/replace.hpp     | 11 ---
 include/boost/range/algorithm/replace_if.hpp  | 11 ---
 include/boost/range/algorithm/reverse.hpp     |  9 --
 .../boost/range/algorithm/reverse_copy.hpp    | 10 +-
 include/boost/range/algorithm/rotate.hpp      | 15 +--
 include/boost/range/algorithm/rotate_copy.hpp |  6 +-
 include/boost/range/algorithm/search.hpp      | 51 -----------
 include/boost/range/algorithm/search_n.hpp    | 80 +++-------------
 include/boost/range/algorithm/sort.hpp        | 18 ----
 .../range/algorithm/stable_partition.hpp      | 20 ----
 include/boost/range/algorithm/stable_sort.hpp | 18 ----
 include/boost/range/algorithm/swap_ranges.hpp | 12 +--
 include/boost/range/algorithm/unique.hpp      | 36 --------
 32 files changed, 37 insertions(+), 821 deletions(-)

diff --git a/include/boost/range/algorithm/adjacent_find.hpp b/include/boost/range/algorithm/adjacent_find.hpp
index 1b88dae..6ff4ad6 100755
--- a/include/boost/range/algorithm/adjacent_find.hpp
+++ b/include/boost/range/algorithm/adjacent_find.hpp
@@ -28,8 +28,8 @@ namespace boost
 ///
 /// \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
+template< class ForwardRange >
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
 adjacent_find(ForwardRange & rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
@@ -37,43 +37,19 @@ adjacent_find(ForwardRange & rng)
 }
 
 /// \overload
-template< typename ForwardRange >
-inline typename range_iterator<const ForwardRange>::type
-adjacent_find(const ForwardRange& rng)
-{
-    BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-    return std::adjacent_find(boost::begin(rng),boost::end(rng));
-}
-
-/// \overload
-template< typename ForwardRange, typename BinaryPredicate >
-inline typename range_iterator<ForwardRange>::type
+template< class ForwardRange, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
 adjacent_find(ForwardRange & rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-    BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
-        typename range_value<ForwardRange>::type,
-        typename range_value<ForwardRange>::type>));
-    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_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-    BOOST_RANGE_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
-template< range_return_value re, typename ForwardRange >
-inline typename range_return<ForwardRange,re>::type
+template< range_return_value re, class ForwardRange >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
 adjacent_find(ForwardRange & rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
@@ -83,41 +59,16 @@ adjacent_find(ForwardRange & rng)
 }
 
 /// \overload
-template< range_return_value re, typename ForwardRange >
-inline typename range_return<const ForwardRange,re>::type
-adjacent_find(const ForwardRange& rng)
-{
-    BOOST_RANGE_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
+template< range_return_value re, class ForwardRange, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
 adjacent_find(ForwardRange& rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-    BOOST_RANGE_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_RANGE_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
diff --git a/include/boost/range/algorithm/count.hpp b/include/boost/range/algorithm/count.hpp
index 8316ce0..3174dc0 100755
--- a/include/boost/range/algorithm/count.hpp
+++ b/include/boost/range/algorithm/count.hpp
@@ -27,15 +27,6 @@ namespace boost
 ///
 /// \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_RANGE_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)
 {
diff --git a/include/boost/range/algorithm/count_if.hpp b/include/boost/range/algorithm/count_if.hpp
index ae17b0e..b101226 100755
--- a/include/boost/range/algorithm/count_if.hpp
+++ b/include/boost/range/algorithm/count_if.hpp
@@ -28,15 +28,6 @@ namespace boost
 /// \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_RANGE_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)
 {
diff --git a/include/boost/range/algorithm/equal_range.hpp b/include/boost/range/algorithm/equal_range.hpp
index 4aa4a54..cc3c510 100755
--- a/include/boost/range/algorithm/equal_range.hpp
+++ b/include/boost/range/algorithm/equal_range.hpp
@@ -37,18 +37,6 @@ equal_range(ForwardRange& rng, const Value& val)
     return std::equal_range(boost::begin(rng), boost::end(rng), val);
 }
 
-/// \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_RANGE_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<
@@ -61,18 +49,6 @@ equal_range(ForwardRange& rng, const Value& val, SortPredicate pred)
     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_RANGE_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
diff --git a/include/boost/range/algorithm/for_each.hpp b/include/boost/range/algorithm/for_each.hpp
index 714a06f..f258815 100755
--- a/include/boost/range/algorithm/for_each.hpp
+++ b/include/boost/range/algorithm/for_each.hpp
@@ -33,14 +33,6 @@ inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
     return std::for_each(boost::begin(rng),boost::end(rng),fun);
 }
 
-/// \overload
-template< class SinglePassRange, class UnaryFunction >
-inline UnaryFunction for_each(const SinglePassRange& rng, UnaryFunction fun)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
-    return std::for_each(boost::begin(rng), boost::end(rng), fun);
-}
-
     } // namespace range
     using range::for_each;
 } // namespace boost
diff --git a/include/boost/range/algorithm/generate.hpp b/include/boost/range/algorithm/generate.hpp
index 97a0d9d..bd63a48 100755
--- a/include/boost/range/algorithm/generate.hpp
+++ b/include/boost/range/algorithm/generate.hpp
@@ -33,15 +33,6 @@ inline ForwardRange& generate( ForwardRange& rng, Generator gen )
     return rng;
 }
 
-/// \overload
-template< class ForwardRange, class Generator >
-inline const ForwardRange& generate(const ForwardRange& rng, Generator gen)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    std::generate(boost::begin(rng), boost::end(rng), gen);
-    return rng;
-}
-
     } // namespace range
     using range::generate;
 } // namespace boost
diff --git a/include/boost/range/algorithm/heap_algorithm.hpp b/include/boost/range/algorithm/heap_algorithm.hpp
index 3a6d392..64df3e9 100755
--- a/include/boost/range/algorithm/heap_algorithm.hpp
+++ b/include/boost/range/algorithm/heap_algorithm.hpp
@@ -27,18 +27,10 @@ namespace boost
 /// \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)
+inline RandomAccessRange& push_heap(RandomAccessRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
     std::push_heap(boost::begin(rng), boost::end(rng));
-}
-
-/// \overload
-template<class RandomAccessRange>
-inline const RandomAccessRange& push_heap(const RandomAccessRange& rng)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::push_heap(boost::begin(rng), boost::end(rng));
     return rng;
 }
 
@@ -51,15 +43,6 @@ inline RandomAccessRange& push_heap(RandomAccessRange& rng, Compare comp_pred)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange, class Compare>
-inline const RandomAccessRange& push_heap(const RandomAccessRange& rng, Compare comp_pred)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    return rng;
-}
-
 /// \brief template function pop_heap
 ///
 /// range-based version of the pop_heap std algorithm
@@ -74,15 +57,6 @@ inline RandomAccessRange& pop_heap(RandomAccessRange& rng)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange>
-inline const RandomAccessRange& pop_heap(const RandomAccessRange& rng)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::pop_heap(boost::begin(rng),boost::end(rng));
-    return rng;
-}
-
 /// \overload
 template<class RandomAccessRange, class Compare>
 inline RandomAccessRange& pop_heap(RandomAccessRange& rng, Compare comp_pred)
@@ -92,15 +66,6 @@ inline RandomAccessRange& pop_heap(RandomAccessRange& rng, Compare comp_pred)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange, class Compare>
-inline const RandomAccessRange& pop_heap(const RandomAccessRange& rng, Compare comp_pred)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    return rng;
-}
-
 /// \brief template function make_heap
 ///
 /// range-based version of the make_heap std algorithm
@@ -115,15 +80,6 @@ inline RandomAccessRange& make_heap(RandomAccessRange& rng)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange>
-inline RandomAccessRange& make_heap(const RandomAccessRange& rng)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::make_heap(boost::begin(rng),boost::end(rng));
-    return rng;
-}
-
 /// \overload
 template<class RandomAccessRange, class Compare>
 inline RandomAccessRange& make_heap(RandomAccessRange& rng, Compare comp_pred)
@@ -133,15 +89,6 @@ inline RandomAccessRange& make_heap(RandomAccessRange& rng, Compare comp_pred)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange, class Compare>
-inline const RandomAccessRange& make_heap(const RandomAccessRange& rng, Compare comp_pred)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    return rng;
-}
-
 /// \brief template function sort_heap
 ///
 /// range-based version of the sort_heap std algorithm
@@ -156,15 +103,6 @@ inline RandomAccessRange& sort_heap(RandomAccessRange& rng)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange>
-inline const RandomAccessRange& sort_heap(const RandomAccessRange& rng)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::sort_heap(boost::begin(rng), boost::end(rng));
-    return rng;
-}
-
 /// \overload
 template<class RandomAccessRange, class Compare>
 inline RandomAccessRange& sort_heap(RandomAccessRange& rng, Compare comp_pred)
@@ -174,15 +112,6 @@ inline RandomAccessRange& sort_heap(RandomAccessRange& rng, Compare comp_pred)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange, class Compare>
-inline const RandomAccessRange& sort_heap(const RandomAccessRange& rng, Compare comp_pred)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
-    return rng;
-}
-
     } // namespace range
     using range::push_heap;
     using range::pop_heap;
diff --git a/include/boost/range/algorithm/inplace_merge.hpp b/include/boost/range/algorithm/inplace_merge.hpp
index dfadbaa..80c13f4 100755
--- a/include/boost/range/algorithm/inplace_merge.hpp
+++ b/include/boost/range/algorithm/inplace_merge.hpp
@@ -35,16 +35,6 @@ inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
     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_RANGE_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,
@@ -56,17 +46,6 @@ inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
     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_RANGE_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
diff --git a/include/boost/range/algorithm/max_element.hpp b/include/boost/range/algorithm/max_element.hpp
index a0c1ffd..d8ec692 100755
--- a/include/boost/range/algorithm/max_element.hpp
+++ b/include/boost/range/algorithm/max_element.hpp
@@ -35,15 +35,6 @@ max_element(ForwardRange& rng)
     return std::max_element(boost::begin(rng), boost::end(rng));
 }
 
-/// \overload
-template<class ForwardRange>
-inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
-max_element(const ForwardRange& rng)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return std::max_element(boost::begin(rng), boost::end(rng));
-}
-
 /// \overload
 template<class ForwardRange, class BinaryPredicate>
 inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
@@ -53,15 +44,6 @@ max_element(ForwardRange& rng, BinaryPredicate 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_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return std::max_element(boost::begin(rng), boost::end(rng), pred);
-}
-
 // range_return overloads
 
 /// \overload
@@ -75,17 +57,6 @@ max_element(ForwardRange& 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_RANGE_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
@@ -97,17 +68,6 @@ max_element(ForwardRange& rng, BinaryPredicate 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_RANGE_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
diff --git a/include/boost/range/algorithm/min_element.hpp b/include/boost/range/algorithm/min_element.hpp
index c966b1e..3bc02da 100755
--- a/include/boost/range/algorithm/min_element.hpp
+++ b/include/boost/range/algorithm/min_element.hpp
@@ -35,15 +35,6 @@ min_element(ForwardRange& rng)
     return std::min_element(boost::begin(rng), boost::end(rng));
 }
 
-/// \overload
-template<class ForwardRange>
-inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
-min_element(const ForwardRange& rng)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return std::min_element(boost::begin(rng), boost::end(rng));
-}
-
 /// \overload
 template<class ForwardRange, class BinaryPredicate>
 inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
@@ -53,15 +44,6 @@ min_element(ForwardRange& rng, BinaryPredicate 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_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return std::min_element(boost::begin(rng), boost::end(rng), pred);
-}
-
 // range_return overloads
 
 /// \overload
@@ -75,17 +57,6 @@ min_element(ForwardRange& 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_RANGE_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
@@ -97,17 +68,6 @@ min_element(ForwardRange& rng, BinaryPredicate 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_RANGE_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
diff --git a/include/boost/range/algorithm/mismatch.hpp b/include/boost/range/algorithm/mismatch.hpp
index 2819c33..c0cde9b 100755
--- a/include/boost/range/algorithm/mismatch.hpp
+++ b/include/boost/range/algorithm/mismatch.hpp
@@ -69,36 +69,6 @@ namespace boost
 /// \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_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
-    BOOST_RANGE_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<const SinglePassRange1>::type,
-    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
-mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-    BOOST_RANGE_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 >
@@ -112,52 +82,6 @@ mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2)
         ::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_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-    BOOST_RANGE_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_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
-    BOOST_RANGE_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_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-    BOOST_RANGE_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<
@@ -173,21 +97,6 @@ mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
         ::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_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-    BOOST_RANGE_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
diff --git a/include/boost/range/algorithm/nth_element.hpp b/include/boost/range/algorithm/nth_element.hpp
index 94fbe80..cf143e9 100755
--- a/include/boost/range/algorithm/nth_element.hpp
+++ b/include/boost/range/algorithm/nth_element.hpp
@@ -35,16 +35,6 @@ inline RandomAccessRange& nth_element(RandomAccessRange& rng,
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange>
-inline const RandomAccessRange& nth_element(const RandomAccessRange& rng,
-    BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::nth_element(boost::begin(rng),nth,boost::end(rng));
-    return rng;
-}
-
 /// \overload
 template<class RandomAccessRange, class BinaryPredicate>
 inline RandomAccessRange& nth_element(RandomAccessRange& rng,
@@ -56,17 +46,6 @@ inline RandomAccessRange& nth_element(RandomAccessRange& rng,
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange, class BinaryPredicate>
-inline const RandomAccessRange& nth_element(const RandomAccessRange& rng,
-    BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth,
-    BinaryPredicate sort_pred)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred);
-    return rng;
-}
-
     } // namespace range
     using range::nth_element;
 } // namespace boost
diff --git a/include/boost/range/algorithm/partial_sort.hpp b/include/boost/range/algorithm/partial_sort.hpp
index a36af87..1797c55 100755
--- a/include/boost/range/algorithm/partial_sort.hpp
+++ b/include/boost/range/algorithm/partial_sort.hpp
@@ -35,16 +35,6 @@ inline RandomAccessRange& partial_sort(RandomAccessRange& rng,
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange>
-inline const RandomAccessRange& partial_sort(const RandomAccessRange& rng,
-    BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::partial_sort(boost::begin(rng), middle, boost::end(rng));
-    return rng;
-}
-
 /// \overload
 template<class RandomAccessRange, class BinaryPredicate>
 inline RandomAccessRange& partial_sort(RandomAccessRange& rng,
@@ -57,17 +47,6 @@ inline RandomAccessRange& partial_sort(RandomAccessRange& rng,
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange, class BinaryPredicate>
-inline const RandomAccessRange& partial_sort(const RandomAccessRange& rng,
-    BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle,
-    BinaryPredicate sort_pred)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred);
-    return rng;
-}
-
     } // namespace range
     using range::partial_sort;
 } // namespace boost
diff --git a/include/boost/range/algorithm/partial_sort_copy.hpp b/include/boost/range/algorithm/partial_sort_copy.hpp
index 8cf3510..a2fe761 100755
--- a/include/boost/range/algorithm/partial_sort_copy.hpp
+++ b/include/boost/range/algorithm/partial_sort_copy.hpp
@@ -28,30 +28,24 @@ namespace boost
 /// \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
+template<class SinglePassRange, class RandomAccessRange>
+inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type
 partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2)
 {
     BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
-    BOOST_RANGE_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
-    BOOST_RANGE_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
-    BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
 
     return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
         boost::begin(rng2), boost::end(rng2));
 }
 
 /// \overload
-template<typename SinglePassRange, typename RandomAccessRange,
-         typename BinaryPredicate>
-inline typename range_iterator<RandomAccessRange>::type
+template<class SinglePassRange, class RandomAccessRange,
+         class BinaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type
 partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2,
     BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
-    BOOST_RANGE_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
-    BOOST_RANGE_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
-    BOOST_RANGE_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);
diff --git a/include/boost/range/algorithm/partition.hpp b/include/boost/range/algorithm/partition.hpp
index 05f41da..6404918 100755
--- a/include/boost/range/algorithm/partition.hpp
+++ b/include/boost/range/algorithm/partition.hpp
@@ -34,15 +34,6 @@ partition(ForwardRange& rng, UnaryPredicate pred)
     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_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return std::partition(boost::begin(rng),boost::end(rng),pred);
-}
-
 // range_return overloads
 
 /// \overload
@@ -56,17 +47,6 @@ partition(ForwardRange& rng, UnaryPredicate pred)
         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_RANGE_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
diff --git a/include/boost/range/algorithm/permutation.hpp b/include/boost/range/algorithm/permutation.hpp
index 75388cc..7540c96 100755
--- a/include/boost/range/algorithm/permutation.hpp
+++ b/include/boost/range/algorithm/permutation.hpp
@@ -33,14 +33,6 @@ inline bool next_permutation(BidirectionalRange& rng)
     return std::next_permutation(boost::begin(rng), boost::end(rng));
 }
 
-/// \overload
-template<class BidirectionalRange>
-inline bool next_permutation(const BidirectionalRange& rng)
-{
-    BOOST_RANGE_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)
@@ -50,16 +42,6 @@ inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
                                  comp_pred);
 }
 
-/// \overload
-template<class BidirectionalRange, class Compare>
-inline bool next_permutation(const BidirectionalRange& rng,
-                             Compare                   comp_pred)
-{
-    BOOST_RANGE_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
@@ -73,14 +55,6 @@ inline bool prev_permutation(BidirectionalRange& rng)
     return std::prev_permutation(boost::begin(rng), boost::end(rng));
 }
 
-/// \overload
-template<class BidirectionalRange>
-inline bool prev_permutation(const BidirectionalRange& rng)
-{
-    BOOST_RANGE_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)
@@ -90,16 +64,6 @@ inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
                                  comp_pred);
 }
 
-/// \overload
-template<class BidirectionalRange, class Compare>
-inline bool prev_permutation(const BidirectionalRange& rng,
-                             Compare                   comp_pred)
-{
-    BOOST_RANGE_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;
diff --git a/include/boost/range/algorithm/random_shuffle.hpp b/include/boost/range/algorithm/random_shuffle.hpp
index eeae3d7..0b17333 100755
--- a/include/boost/range/algorithm/random_shuffle.hpp
+++ b/include/boost/range/algorithm/random_shuffle.hpp
@@ -34,15 +34,6 @@ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange>
-inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
-{
-    BOOST_RANGE_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)
@@ -52,15 +43,6 @@ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange, class Generator>
-inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
-{
-    BOOST_RANGE_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
diff --git a/include/boost/range/algorithm/remove.hpp b/include/boost/range/algorithm/remove.hpp
index 699a7cd..638dff2 100755
--- a/include/boost/range/algorithm/remove.hpp
+++ b/include/boost/range/algorithm/remove.hpp
@@ -34,15 +34,6 @@ remove(ForwardRange& rng, const Value& val)
     return std::remove(boost::begin(rng),boost::end(rng),val);
 }
 
-/// \overload
-template< class ForwardRange, class Value >
-inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
-remove(const ForwardRange& rng, const Value& val)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return std::remove(boost::begin(rng),boost::end(rng),val);
-}
-
 // range_return overloads
 
 /// \overload
@@ -56,17 +47,6 @@ remove(ForwardRange& rng, const Value& 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_RANGE_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
diff --git a/include/boost/range/algorithm/remove_if.hpp b/include/boost/range/algorithm/remove_if.hpp
index babcddc..349e7a4 100755
--- a/include/boost/range/algorithm/remove_if.hpp
+++ b/include/boost/range/algorithm/remove_if.hpp
@@ -35,15 +35,6 @@ remove_if(ForwardRange& rng, UnaryPredicate pred)
     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_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return std::remove_if(boost::begin(rng),boost::end(rng),pred);
-}
-
 // range_return overloads
 
 /// \overload
@@ -57,17 +48,6 @@ remove_if(ForwardRange& rng, UnaryPredicate 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_RANGE_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
diff --git a/include/boost/range/algorithm/replace.hpp b/include/boost/range/algorithm/replace.hpp
index 44d3e4c..3f2d72c 100755
--- a/include/boost/range/algorithm/replace.hpp
+++ b/include/boost/range/algorithm/replace.hpp
@@ -35,17 +35,6 @@ replace(ForwardRange& rng, const Value& what,
     return rng;
 }
 
-/// \overload
-template< class ForwardRange, class Value >
-inline const ForwardRange&
-replace(const ForwardRange& rng, const Value& what,
-        const Value& with_what)
-{
-    BOOST_RANGE_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;
diff --git a/include/boost/range/algorithm/replace_if.hpp b/include/boost/range/algorithm/replace_if.hpp
index 93d5a1f..393a4ca 100755
--- a/include/boost/range/algorithm/replace_if.hpp
+++ b/include/boost/range/algorithm/replace_if.hpp
@@ -36,17 +36,6 @@ inline ForwardRange&
     return rng;
 }
 
-/// \overload
-template< class ForwardRange, class UnaryPredicate, class Value >
-inline const ForwardRange&
-    replace_if(const ForwardRange& rng, UnaryPredicate pred,
-               const Value& val)
-{
-    BOOST_RANGE_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
diff --git a/include/boost/range/algorithm/reverse.hpp b/include/boost/range/algorithm/reverse.hpp
index 20a7eb1..8741d66 100755
--- a/include/boost/range/algorithm/reverse.hpp
+++ b/include/boost/range/algorithm/reverse.hpp
@@ -34,15 +34,6 @@ inline BidirectionalRange& reverse(BidirectionalRange& rng)
     return rng;
 }
 
-/// \overload
-template<class BidirectionalRange>
-inline const BidirectionalRange& reverse(const BidirectionalRange& rng)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
-    std::reverse(boost::begin(rng), boost::end(rng));
-    return rng;
-}
-
     } // namespace range
     using range::reverse;
 } // namespace boost
diff --git a/include/boost/range/algorithm/reverse_copy.hpp b/include/boost/range/algorithm/reverse_copy.hpp
index 381f157..d86145d 100755
--- a/include/boost/range/algorithm/reverse_copy.hpp
+++ b/include/boost/range/algorithm/reverse_copy.hpp
@@ -26,15 +26,7 @@ namespace boost
 /// 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_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
-    return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
-}
-
-/// \overload
-template<typename BidirectionalRange, typename OutputIterator>
+template<class BidirectionalRange, class OutputIterator>
 inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
diff --git a/include/boost/range/algorithm/rotate.hpp b/include/boost/range/algorithm/rotate.hpp
index 2372a00..aef6062 100755
--- a/include/boost/range/algorithm/rotate.hpp
+++ b/include/boost/range/algorithm/rotate.hpp
@@ -25,26 +25,15 @@ namespace boost
 /// range-based version of the rotate std algorithm
 ///
 /// \pre Rng meets the requirements for a Forward range
-template<typename ForwardRange>
+template<class ForwardRange>
 inline ForwardRange& rotate(ForwardRange& rng,
-    typename range_iterator<ForwardRange>::type middle)
+    BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type middle)
 {
     BOOST_RANGE_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_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    std::rotate(boost::begin(rng), middle, boost::end(rng));
-    return rng;
-}
-
     } // namespace range
     using range::rotate;
 } // namespace boost
diff --git a/include/boost/range/algorithm/rotate_copy.hpp b/include/boost/range/algorithm/rotate_copy.hpp
index 9030f73..0409ac5 100755
--- a/include/boost/range/algorithm/rotate_copy.hpp
+++ b/include/boost/range/algorithm/rotate_copy.hpp
@@ -28,9 +28,9 @@ namespace boost
     /// \pre Rng meets the requirements for a Forward range
     template<typename ForwardRange, typename OutputIterator>
     inline OutputIterator rotate_copy(
-        const ForwardRange&                                 rng,
-        typename range_iterator<const ForwardRange>::type   middle,
-        OutputIterator                                      target
+        const ForwardRange&                                             rng,
+        BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type middle,
+        OutputIterator                                                  target
         )
     {
         BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
diff --git a/include/boost/range/algorithm/search.hpp b/include/boost/range/algorithm/search.hpp
index 45d7ade..3f5134f 100755
--- a/include/boost/range/algorithm/search.hpp
+++ b/include/boost/range/algorithm/search.hpp
@@ -38,17 +38,6 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2)
                        boost::begin(rng2),boost::end(rng2));
 }
 
-/// \overload
-template< class ForwardRange1, class ForwardRange2 >
-inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
-search(const ForwardRange1& rng1, const ForwardRange2& rng2)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
-    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
-    return std::search(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
@@ -60,18 +49,6 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate 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_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
-    BOOST_RANGE_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
@@ -87,19 +64,6 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2)
              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_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
-    BOOST_RANGE_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 >
@@ -114,21 +78,6 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate 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_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
-    BOOST_RANGE_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
diff --git a/include/boost/range/algorithm/search_n.hpp b/include/boost/range/algorithm/search_n.hpp
index cd0340b..dfbb17a 100755
--- a/include/boost/range/algorithm/search_n.hpp
+++ b/include/boost/range/algorithm/search_n.hpp
@@ -31,8 +31,8 @@ namespace boost
 /// \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
+template< class ForwardRange, class Integer, class Value >
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
 search_n(ForwardRange& rng, Integer count, const Value& value)
 {
     BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
@@ -40,38 +40,13 @@ search_n(ForwardRange& rng, Integer count, const Value& value)
 }
 
 /// \overload
-template< typename ForwardRange, typename Integer, typename Value >
-inline typename range_iterator<const ForwardRange>::type
-search_n(const ForwardRange& rng, Integer count, const Value& value)
-{
-    BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-    return std::search_n(boost::begin(rng), boost::end(rng), count, value);
-}
-
-/// \overload
-template< typename ForwardRange, typename Integer, class Value,
-          typename BinaryPredicate >
-inline typename range_iterator<ForwardRange>::type
+template< class ForwardRange, class Integer, class Value,
+          class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
 search_n(ForwardRange& rng, Integer count, const Value& value,
          BinaryPredicate binary_pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-    BOOST_RANGE_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
-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_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-    BOOST_RANGE_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);
 }
@@ -79,9 +54,9 @@ search_n(const ForwardRange& rng, Integer count, const Value& value,
 // range_return overloads
 
 /// \overload
-template< range_return_value re, typename ForwardRange, typename Integer,
-          typename Value >
-inline typename range_return<ForwardRange,re>::type
+template< range_return_value re, class ForwardRange, class Integer,
+          class Value >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
 search_n(ForwardRange& rng, Integer count, const Value& value)
 {
     BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
@@ -92,52 +67,19 @@ search_n(ForwardRange& rng, Integer count, const Value& value)
 }
 
 /// \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_RANGE_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
+template< range_return_value re, class ForwardRange, class Integer,
+          class Value, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
 search_n(ForwardRange& rng, Integer count, const Value& value,
          BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-    BOOST_RANGE_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_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-    BOOST_RANGE_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
diff --git a/include/boost/range/algorithm/sort.hpp b/include/boost/range/algorithm/sort.hpp
index a160907..0c6e3b2 100755
--- a/include/boost/range/algorithm/sort.hpp
+++ b/include/boost/range/algorithm/sort.hpp
@@ -34,15 +34,6 @@ inline RandomAccessRange& sort(RandomAccessRange& rng)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange>
-inline const RandomAccessRange& sort(const RandomAccessRange& rng)
-{
-    BOOST_RANGE_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)
@@ -52,15 +43,6 @@ inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange, class BinaryPredicate>
-inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred)
-{
-    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
-    std::sort(boost::begin(rng), boost::end(rng), pred);
-    return rng;
-}
-
     } // namespace range
     using range::sort;
 } // namespace boost
diff --git a/include/boost/range/algorithm/stable_partition.hpp b/include/boost/range/algorithm/stable_partition.hpp
index 24febfc..aa003df 100755
--- a/include/boost/range/algorithm/stable_partition.hpp
+++ b/include/boost/range/algorithm/stable_partition.hpp
@@ -35,15 +35,6 @@ stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
     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_RANGE_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
@@ -55,17 +46,6 @@ stable_partition(BidirectionalRange& rng, UnaryPredicate 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_RANGE_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
diff --git a/include/boost/range/algorithm/stable_sort.hpp b/include/boost/range/algorithm/stable_sort.hpp
index d18da4d..6a27aa4 100755
--- a/include/boost/range/algorithm/stable_sort.hpp
+++ b/include/boost/range/algorithm/stable_sort.hpp
@@ -34,15 +34,6 @@ inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange>
-inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
-{
-    BOOST_RANGE_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)
@@ -52,15 +43,6 @@ inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate so
     return rng;
 }
 
-/// \overload
-template<class RandomAccessRange, class BinaryPredicate>
-inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred)
-{
-    BOOST_RANGE_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
diff --git a/include/boost/range/algorithm/swap_ranges.hpp b/include/boost/range/algorithm/swap_ranges.hpp
index 1acee0d..5b8967a 100755
--- a/include/boost/range/algorithm/swap_ranges.hpp
+++ b/include/boost/range/algorithm/swap_ranges.hpp
@@ -22,7 +22,7 @@ namespace boost
 {
     namespace range_detail
     {
-        template<typename Iterator1, typename Iterator2>
+        template<class Iterator1, class Iterator2>
         void swap_ranges_impl(Iterator1 it1, Iterator1 last1,
                               Iterator2 it2, Iterator2 last2,
                               single_pass_traversal_tag,
@@ -36,7 +36,7 @@ namespace boost
             }
         }
 
-        template<typename Iterator1, typename Iterator2>
+        template<class Iterator1, class Iterator2>
         void swap_ranges_impl(Iterator1 it1, Iterator1 last1,
                               Iterator2 it2, Iterator2 last2,
                               random_access_traversal_tag,
@@ -47,13 +47,13 @@ namespace boost
             std::swap_ranges(it1, last1, it2);
         }
 
-        template<typename Iterator1, typename Iterator2>
+        template<class Iterator1, class Iterator2>
         void swap_ranges_impl(Iterator1 first1, Iterator1 last1,
                               Iterator2 first2, Iterator2 last2)
         {
             swap_ranges_impl(first1, last1, first2, last2,
-                typename iterator_traversal<Iterator1>::type(),
-                typename iterator_traversal<Iterator2>::type());
+                BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator1>::type(),
+                BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator2>::type());
         }
     } // namespace range_detail
 
@@ -66,7 +66,7 @@ namespace boost
 ///
 /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
 /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
-template< typename SinglePassRange1, typename SinglePassRange2 >
+template< class SinglePassRange1, class SinglePassRange2 >
 inline SinglePassRange2&
 swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2)
 {
diff --git a/include/boost/range/algorithm/unique.hpp b/include/boost/range/algorithm/unique.hpp
index be6eaf9..b930c54 100755
--- a/include/boost/range/algorithm/unique.hpp
+++ b/include/boost/range/algorithm/unique.hpp
@@ -36,16 +36,6 @@ unique( ForwardRange& rng )
                            boost::end(rng)), rng );
 }
 
-/// \overload
-template< range_return_value re, class ForwardRange >
-inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
-unique( const ForwardRange& rng )
-{
-    BOOST_RANGE_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
@@ -56,16 +46,6 @@ unique( ForwardRange& rng, BinaryPredicate pred )
         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_RANGE_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 >
@@ -76,14 +56,6 @@ unique( ForwardRange& rng )
     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_RANGE_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 )
@@ -91,14 +63,6 @@ unique( ForwardRange& rng, BinaryPredicate pred )
     BOOST_RANGE_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_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return ::boost::range::unique<return_begin_found>(rng, pred);
-}
 
     } // namespace range
     using range::unique;