diff --git a/include/boost/algorithm/string/case_conv.hpp b/include/boost/algorithm/string/case_conv.hpp
index ff7227e..70eb78c 100644
--- a/include/boost/algorithm/string/case_conv.hpp
+++ b/include/boost/algorithm/string/case_conv.hpp
@@ -39,7 +39,7 @@ namespace boost {
             It is returned as a sequence or copied to the output iterator.
 
             \param Output An output iterator to which the result will be copied
-            \param Input An input collection
+            \param Input An input range
             \param Loc A locale used for conversion
             \return 
                 An output iterator pointing just after the last inserted character or
@@ -48,11 +48,11 @@ namespace boost {
             \note The second variant of this function provides the strong exception-safety guarantee
                 
         */
-        template<typename OutputIteratorT, typename CollectionT>
+        template<typename OutputIteratorT, typename RangeT>
         inline OutputIteratorT 
         to_lower_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             const std::locale& Loc=std::locale())
         {
             return std::transform( 
@@ -60,7 +60,7 @@ namespace boost {
                 end(Input), 
                 Output,
                 detail::to_lowerF<
-                    typename range_value<CollectionT>::type >(Loc));
+                    typename range_value<RangeT>::type >(Loc));
         }
 
         //! Convert to lower case
@@ -88,12 +88,12 @@ namespace boost {
             Each element of the input sequence is converted to lower
             case. The input sequence is modified in-place.
 
-            \param Input A collection
+            \param Input A range
             \param Loc a locale used for conversion
         */
-        template<typename MutableCollectionT>
+        template<typename WritableRangeT>
         inline void to_lower( 
-            MutableCollectionT& Input, 
+            WritableRangeT& Input, 
             const std::locale& Loc=std::locale())
         {
             std::transform( 
@@ -101,7 +101,7 @@ namespace boost {
                 end(Input), 
                 begin(Input), 
                 detail::to_lowerF<
-                    typename range_value<MutableCollectionT>::type >(Loc));
+                    typename range_value<WritableRangeT>::type >(Loc));
         }
         
 //  to_upper  -----------------------------------------------//
@@ -113,7 +113,7 @@ namespace boost {
             It is returned as a sequence or copied to the output iterator
 
             \param Output An output iterator to which the result will be copied
-            \param Input An input collection
+            \param Input An input range
             \param Loc A locale used for conversion
             \return 
                 An output iterator pointing just after the last inserted character or
@@ -121,11 +121,11 @@ namespace boost {
 
             \note The second variant of this function provides the strong exception-safety guarantee
         */
-        template<typename OutputIteratorT, typename CollectionT>
+        template<typename OutputIteratorT, typename RangeT>
         inline OutputIteratorT 
         to_upper_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             const std::locale& Loc=std::locale())
         {
             return std::transform( 
@@ -133,7 +133,7 @@ namespace boost {
                 end(Input), 
                 Output,
                 detail::to_upperF<
-                    typename range_value<CollectionT>::type >(Loc));
+                    typename range_value<RangeT>::type >(Loc));
         }
 
         //! Convert to upper case
@@ -162,12 +162,12 @@ namespace boost {
             Each element of the input sequence is converted to upper
             case. The input sequence is modified in-place.
 
-            \param Input An input collection
+            \param Input An input range
             \param Loc a locale used for conversion
         */
-        template<typename MutableCollectionT>
+        template<typename WritableRangeT>
         inline void to_upper( 
-            MutableCollectionT& Input, 
+            WritableRangeT& Input, 
             const std::locale& Loc=std::locale())
         {
             std::transform( 
@@ -175,7 +175,7 @@ namespace boost {
                 end(Input), 
                 begin(Input), 
                 detail::to_upperF<
-                    typename range_value<MutableCollectionT>::type >(Loc));
+                    typename range_value<WritableRangeT>::type >(Loc));
         }
 
     } // namespace algorithm
diff --git a/include/boost/algorithm/string/classification.hpp b/include/boost/algorithm/string/classification.hpp
index 7dd65d2..232050f 100644
--- a/include/boost/algorithm/string/classification.hpp
+++ b/include/boost/algorithm/string/classification.hpp
@@ -194,13 +194,13 @@ namespace boost {
             \param Set A set of characters to be recognized
             \return An instance of the \c is_any_of predicate 
         */
-        template<typename ContainerT>
+        template<typename RangeT>
         inline detail::is_any_ofF<
-            BOOST_STRING_TYPENAME range_value<ContainerT>::type> 
-        is_any_of( const ContainerT& Set )
+            BOOST_STRING_TYPENAME range_value<RangeT>::type> 
+        is_any_of( const RangeT& Set )
         {
             return detail::is_any_ofF<
-                BOOST_STRING_TYPENAME range_value<ContainerT>::type>(Set); 
+                BOOST_STRING_TYPENAME range_value<RangeT>::type>(Set); 
         }
 
         //! is_from_range predicate
diff --git a/include/boost/algorithm/string/detail/classification.hpp b/include/boost/algorithm/string/detail/classification.hpp
index 2adfaae..06c85a9 100644
--- a/include/boost/algorithm/string/detail/classification.hpp
+++ b/include/boost/algorithm/string/detail/classification.hpp
@@ -63,9 +63,9 @@ namespace boost {
                 template <class Args> struct sig { typedef bool type; };
 
                 // Constructor 
-                template< typename SeqT >
-                is_any_ofF( const SeqT& Seq ) : 
-                    m_Set( begin(Seq), end(Seq) ) {}
+                template<typename RangeT>
+                is_any_ofF( const RangeT& Range ) : 
+                    m_Set( begin(Range), end(Range) ) {}
                 
                 // Operation
                 template<typename Char2T>
diff --git a/include/boost/algorithm/string/detail/formatter.hpp b/include/boost/algorithm/string/detail/formatter.hpp
index a40327c..ab58b6c 100644
--- a/include/boost/algorithm/string/detail/formatter.hpp
+++ b/include/boost/algorithm/string/detail/formatter.hpp
@@ -27,22 +27,22 @@ namespace boost {
 //  const format functor ----------------------------------------------------//
 
             // constant format functor
-            template<typename CollectionT>
+            template<typename RangeT>
             struct const_formatF
             {
             private:
                 typedef BOOST_STRING_TYPENAME
-                    range_const_iterator<CollectionT>::type format_iterator;
+                    range_const_iterator<RangeT>::type format_iterator;
                 typedef iterator_range<format_iterator> result_type;
             
             public:
                 // Construction
-                const_formatF(const CollectionT& Format) :
+                const_formatF(const RangeT& Format) :
                     m_Format(begin(Format), end(Format)) {}
 
                 // Operation
-                template<typename Collection2T>
-                const result_type& operator()(const Collection2T&) const
+                template<typename Range2T>
+                const result_type& operator()(const Range2T&) const
                 {
                     return m_Format;
                 }
@@ -54,14 +54,14 @@ namespace boost {
 //  identity format functor ----------------------------------------------------//
 
             // identity format functor
-            template<typename CollectionT>
+            template<typename RangeT>
             struct identity_formatF
             {
                 // Operation
-                template< typename Collection2T >
-                const CollectionT& operator()(const Collection2T& Replace) const
+                template< typename Range2T >
+                const RangeT& operator()(const Range2T& Replace) const
                 {
-                    return CollectionT(begin(Replace), end(Replace));
+                    return RangeT(begin(Replace), end(Replace));
                 }
             };
 
diff --git a/include/boost/algorithm/string/erase.hpp b/include/boost/algorithm/string/erase.hpp
index 724bb9c..dd499d6 100644
--- a/include/boost/algorithm/string/erase.hpp
+++ b/include/boost/algorithm/string/erase.hpp
@@ -45,13 +45,13 @@ namespace boost {
 
             \note The second variant of this function provides the strong exception-safety guarantee
         */
-        template<typename OutputIteratorT, typename CollectionT>
+        template<typename OutputIteratorT, typename RangeT>
         inline OutputIteratorT erase_range_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             const iterator_range<
                 BOOST_STRING_TYPENAME 
-                    range_const_iterator<CollectionT>::type>& SearchRange )
+                    range_const_iterator<RangeT>::type>& SearchRange )
         {
             return find_format_copy(
                 Output,
@@ -116,12 +116,12 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT erase_first_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search )
+            const Range1T& Input,
+            const Range2T& Search )
         {
             return find_format_copy(
                 Output,
@@ -134,10 +134,10 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT erase_first_copy( 
             const SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             return find_format_copy( 
                 Input, 
@@ -153,10 +153,10 @@ namespace boost {
             \param Input An input string
             \param Search A substring to be searched for. 
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void erase_first( 
             SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             find_format( 
                 Input, 
@@ -184,12 +184,12 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT ierase_first_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy(
@@ -203,10 +203,10 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT ierase_first_copy( 
             const SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy( 
@@ -224,10 +224,10 @@ namespace boost {
             \param Search A substring to be searched for
             \param Loc A locale used for case insensitive comparison
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void ierase_first( 
             SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             find_format( 
@@ -254,12 +254,12 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT erase_last_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search )
+            const Range1T& Input,
+            const Range2T& Search )
         {
             return find_format_copy(
                 Output,
@@ -272,10 +272,10 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT erase_last_copy( 
             const SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             return find_format_copy( 
                 Input, 
@@ -291,10 +291,10 @@ namespace boost {
             \param Input An input string
             \param Search A substring to be searched for 
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void erase_last( 
             SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             find_format( 
                 Input, 
@@ -322,12 +322,12 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT ierase_last_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy(
@@ -341,10 +341,10 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT ierase_last_copy( 
             const SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy( 
@@ -362,10 +362,10 @@ namespace boost {
             \param Search A substring to be searched for
             \param Loc A locale used for case insensitive comparison
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void ierase_last( 
             SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             find_format( 
@@ -394,12 +394,12 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT erase_nth_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             unsigned int Nth )
         {
             return find_format_copy(
@@ -413,10 +413,10 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT erase_nth_copy( 
             const SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             unsigned int Nth )
         {
             return find_format_copy( 
@@ -434,10 +434,10 @@ namespace boost {
             \param Search A substring to be searched for. 
             \param Nth An index of the match to be replaced. The index is 0-based.
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void erase_nth( 
             SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             unsigned int Nth )
         {
             find_format( 
@@ -467,12 +467,12 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT ierase_nth_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             unsigned int Nth,
             const std::locale& Loc=std::locale() )
         {
@@ -487,10 +487,10 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT ierase_nth_copy( 
             const SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             unsigned int Nth,
             const std::locale& Loc=std::locale() )
         {
@@ -510,10 +510,10 @@ namespace boost {
             \param Nth An index of the match to be replaced. The index is 0-based.
             \param Loc A locale used for case insensitive comparison
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void ierase_nth( 
             SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             unsigned int Nth,
             const std::locale& Loc=std::locale() )
         {
@@ -543,12 +543,12 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT erase_all_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search )
+            const Range1T& Input,
+            const Range2T& Search )
         {
             return find_format_all_copy(
                 Output,
@@ -561,10 +561,10 @@ namespace boost {
         /*!
             \overload
         */  
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT erase_all_copy( 
             const SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             return find_format_all_copy( 
                 Input, 
@@ -580,10 +580,10 @@ namespace boost {
             \param Input An input string
             \param Search A substring to be searched for. 
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void erase_all( 
             SequenceT& Input,
-            const CollectionT& Search )
+            const RangeT& Search )
         {
             find_format_all( 
                 Input, 
@@ -611,12 +611,12 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT ierase_all_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_all_copy(
@@ -630,10 +630,10 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT ierase_all_copy( 
             const SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             return find_format_all_copy( 
@@ -651,10 +651,10 @@ namespace boost {
             \param Search A substring to be searched for. 
             \param Loc A locale used for case insensitive comparison
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void ierase_all( 
             SequenceT& Input,
-            const CollectionT& Search,
+            const RangeT& Search,
             const std::locale& Loc=std::locale() )
         {
             find_format_all( 
@@ -683,10 +683,10 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename CollectionT>
+            typename RangeT>
         inline OutputIteratorT erase_head_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             unsigned int N )
         {
             return find_format_copy(
@@ -751,10 +751,10 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename CollectionT>
+            typename RangeT>
         inline OutputIteratorT erase_tail_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             unsigned int N )
         {
             return find_format_copy(
diff --git a/include/boost/algorithm/string/find.hpp b/include/boost/algorithm/string/find.hpp
index 263d2be..8a2d820 100644
--- a/include/boost/algorithm/string/find.hpp
+++ b/include/boost/algorithm/string/find.hpp
@@ -42,15 +42,15 @@ namespace boost {
             \param Finder Finder object used for searching.
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c CollectionT::iterator or 
-                \c CollectionT::const_iterator, depending on the constness of 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
                 the input parameter.
         */
-        template<typename CollectionT, typename FinderT>
+        template<typename RangeT, typename FinderT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find( 
-            CollectionT& Input, 
+            RangeT& Input, 
             FinderT Finder)
         {
             return Finder(begin(Input),end(Input));
@@ -66,18 +66,18 @@ namespace boost {
             \param Search A substring to be searched for.
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c CollectionT::iterator or 
-                \c CollectionT::const_iterator, depending on the constness of 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
                 the input parameter.
 
               \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         find_first( 
-            Collection1T& Input, 
-            const Collection2T& Search)
+            Range1T& Input, 
+            const Range2T& Search)
         {
             return first_finder(Search)(
                 begin(Input),end(Input));
@@ -93,18 +93,18 @@ namespace boost {
             \param Loc A locale used for case insensitive comparison
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
 
             \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         ifind_first( 
-            Collection1T& Input, 
-            const Collection2T& Search,
+            Range1T& Input, 
+            const Range2T& Search,
             const std::locale& Loc=std::locale())
         {
             return first_finder(Search,is_iequal(Loc))(
@@ -121,18 +121,18 @@ namespace boost {
             \param Search A substring to be searched for.
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
 
             \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         find_last( 
-            Collection1T& Input, 
-            const Collection2T& Search)
+            Range1T& Input, 
+            const Range2T& Search)
         {
             return last_finder(Search)(
                 begin(Input),end(Input));
@@ -148,18 +148,18 @@ namespace boost {
             \param Loc A locale used for case insensitive comparison
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
         
             \note This function provides the strong exception-safety guarantee    
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         ifind_last( 
-            Collection1T& Input, 
-            const Collection2T& Search,
+            Range1T& Input, 
+            const Range2T& Search,
             const std::locale& Loc=std::locale())
         {
             return last_finder(Search, is_iequal(Loc))(
@@ -178,16 +178,16 @@ namespace boost {
             \param Nth An index (zero-indexed) of the match to be found.
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         find_nth( 
-            Collection1T& Input, 
-            const Collection2T& Search,
+            Range1T& Input, 
+            const Range2T& Search,
             unsigned int Nth)
         {
             return nth_finder(Search,Nth)(
@@ -205,19 +205,19 @@ namespace boost {
             \param Loc A locale used for case insensitive comparison
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
 
 
             \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<Collection1T>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<Range1T>::type>
         ifind_nth( 
-            Collection1T& Input, 
-            const Collection2T& Search,
+            Range1T& Input, 
+            const Range2T& Search,
             unsigned int Nth,
             const std::locale& Loc=std::locale())
         {
@@ -237,17 +237,17 @@ namespace boost {
             \param N Length of the head
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c Collection1T::iterator or 
-                \c Collection1T::const_iterator, depending on the constness of 
+                Returned iterator is either \c Range1T::iterator or 
+                \c Range1T::const_iterator, depending on the constness of 
                 the input parameter.
 
             \note This function provides the strong exception-safety guarantee
         */
-        template<typename CollectionT>
+        template<typename RangeT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find_head( 
-            CollectionT& Input, 
+            RangeT& Input, 
             unsigned int N)
         {
             return head_finder(N)(
@@ -266,18 +266,18 @@ namespace boost {
             \param N Length of the tail
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c CollectionT::iterator or 
-                \c CollectionT::const_iterator, depending on the constness of 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
                 the input parameter.
 
 
             \note This function provides the strong exception-safety guarantee
         */
-        template<typename CollectionT>
+        template<typename RangeT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find_tail( 
-            CollectionT& Input, 
+            RangeT& Input, 
             unsigned int N)
         {
             return tail_finder(N)(
@@ -297,17 +297,17 @@ namespace boost {
             \param eCompress Enable/Disable compressing of adjacent tokens
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c CollectionT::iterator or 
-                \c CollectionT::const_iterator, depending on the constness of 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
                 the input parameter.
         
             \note This function provides the strong exception-safety guarantee    
         */
-        template<typename CollectionT, typename PredicateT>
+        template<typename RangeT, typename PredicateT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         find_token( 
-            CollectionT& Input,
+            RangeT& Input,
             PredicateT Pred,
             token_compress_mode_type eCompress=token_compress_off)
         {
diff --git a/include/boost/algorithm/string/find_format.hpp b/include/boost/algorithm/string/find_format.hpp
index c3fbf2f..c2683b9 100644
--- a/include/boost/algorithm/string/find_format.hpp
+++ b/include/boost/algorithm/string/find_format.hpp
@@ -50,23 +50,23 @@ namespace boost {
         */
         template< 
             typename OutputIteratorT,
-            typename CollectionT,
+            typename RangeT,
             typename FinderT,
             typename FormatterT>
         inline OutputIteratorT find_format_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             FinderT Finder,
             FormatterT Formatter )
         {
             // Concept check
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME range_const_iterator<CollectionT>::type> >();
+                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
             function_requires< 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<CollectionT>::type> >();
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
 
             return detail::find_format_copy_impl(
                 Output,
@@ -161,23 +161,23 @@ namespace boost {
         */
         template< 
             typename OutputIteratorT,
-            typename CollectionT,
+            typename RangeT,
             typename FinderT,
             typename FormatterT>
         inline OutputIteratorT find_format_all_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             FinderT Finder,
             FormatterT Formatter)
         {
             // Concept check
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME range_const_iterator<CollectionT>::type> >();
+                BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
             function_requires< 
                 FormatterConcept<
                     FormatterT,
-                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<CollectionT>::type> >();
+                    FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
 
             return detail::find_format_all_copy_impl(
                 Output,
diff --git a/include/boost/algorithm/string/find_iterator.hpp b/include/boost/algorithm/string/find_iterator.hpp
index 580f125..9858199 100644
--- a/include/boost/algorithm/string/find_iterator.hpp
+++ b/include/boost/algorithm/string/find_iterator.hpp
@@ -110,9 +110,9 @@ namespace boost {
                 Construct new find_iterator for a given finder
                 and a collection.
             */
-            template<typename FinderT, typename CollectionT>
+            template<typename FinderT, typename RangeT>
             find_iterator(
-                    CollectionT& Col,
+                    RangeT& Col,
                     FinderT Finder ) :
                 detail::find_iterator_base<IteratorT>(Finder,0),
                 m_Match(begin(Col),begin(Col)),
@@ -178,14 +178,14 @@ namespace boost {
         /*!
          *    Construct a find iterator to iterate through the specified string
          */
-        template<typename CollectionT, typename FinderT>
+        template<typename RangeT, typename FinderT>
         inline find_iterator< 
-            BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         make_find_iterator(
-            CollectionT& Collection,
+            RangeT& Collection,
             FinderT Finder)
         {
-            return find_iterator<BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>(
+            return find_iterator<BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>(
                 begin(Collection), end(Collection), Finder);
         }
 
@@ -273,9 +273,9 @@ namespace boost {
                 Construct new split_iterator for a given finder
                 and a collection.
             */
-            template<typename FinderT, typename CollectionT>
+            template<typename FinderT, typename RangeT>
             split_iterator(
-                    CollectionT& Col,
+                    RangeT& Col,
                     FinderT Finder ) :
                 detail::find_iterator_base<IteratorT>(Finder,0),
                 m_Match(begin(Col),begin(Col)),
@@ -354,14 +354,14 @@ namespace boost {
         /*!
          *    Construct a split iterator to iterate through the specified collection
          */
-        template<typename CollectionT, typename FinderT>
+        template<typename RangeT, typename FinderT>
         inline split_iterator< 
-            BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>
         make_split_iterator(
-            CollectionT& Collection,
+            RangeT& Collection,
             FinderT Finder)
         {
-            return split_iterator<BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type>(
+            return split_iterator<BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type>(
                 begin(Collection), end(Collection), Finder);
         }
 
diff --git a/include/boost/algorithm/string/formatter.hpp b/include/boost/algorithm/string/formatter.hpp
index c95ea2b..74234df 100644
--- a/include/boost/algorithm/string/formatter.hpp
+++ b/include/boost/algorithm/string/formatter.hpp
@@ -40,11 +40,11 @@ namespace boost {
             \param Format A predefined value used as a result for formating
             \return An instance of the \c const_formatter object.
         */
-        template<typename CollectionT>
-        inline detail::const_formatF<CollectionT>
-        const_formatter(const CollectionT& Format)
+        template<typename RangeT>
+        inline detail::const_formatF<RangeT>
+        const_formatter(const RangeT& Format)
         {
-            return detail::const_formatF<CollectionT>(Format);
+            return detail::const_formatF<RangeT>(Format);
         }
 
         //! Identity formatter
@@ -54,11 +54,11 @@ namespace boost {
 
             \return An instance of the \c identity_formatter object.
         */
-        template<typename CollectionT>
-        inline detail::identity_formatF<CollectionT>
+        template<typename RangeT>
+        inline detail::identity_formatF<RangeT>
         identity_formatter()
         {
-            return detail::identity_formatF<CollectionT>();
+            return detail::identity_formatF<RangeT>();
         }
 
         //! Empty formatter
@@ -70,13 +70,13 @@ namespace boost {
                          resulting empty_container<>.
             \return An instance of the \c empty_formatter object.
         */
-        template<typename CollectionT>
+        template<typename RangeT>
         inline detail::empty_formatF< 
-            BOOST_STRING_TYPENAME range_value<CollectionT>::type>
-        empty_formatter(const CollectionT&)
+            BOOST_STRING_TYPENAME range_value<RangeT>::type>
+        empty_formatter(const RangeT&)
         {
             return detail::empty_formatF<
-                BOOST_STRING_TYPENAME range_value<CollectionT>::type>();
+                BOOST_STRING_TYPENAME range_value<RangeT>::type>();
         }
 
 
diff --git a/include/boost/algorithm/string/iter_find.hpp b/include/boost/algorithm/string/iter_find.hpp
index f814747..c9b51ca 100644
--- a/include/boost/algorithm/string/iter_find.hpp
+++ b/include/boost/algorithm/string/iter_find.hpp
@@ -64,20 +64,20 @@ namespace boost {
         */
         template< 
             typename SequenceSequenceT,
-            typename CollectionT,
+            typename RangeT,
             typename FinderT >
         inline SequenceSequenceT&
         iter_find(
             SequenceSequenceT& Result,
-            CollectionT& Input,
+            RangeT& Input,
             FinderT Finder )
         {
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> >();
+                BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
 
             typedef BOOST_STRING_TYPENAME 
-                range_result_iterator<CollectionT>::type input_iterator_type;
+                range_result_iterator<RangeT>::type input_iterator_type;
             typedef find_iterator<input_iterator_type> find_iterator_type;
             typedef detail::copy_iterator_rangeF<
                 BOOST_STRING_TYPENAME 
@@ -131,20 +131,20 @@ namespace boost {
         */
         template< 
             typename SequenceSequenceT,
-            typename CollectionT,
+            typename RangeT,
             typename FinderT >
         inline SequenceSequenceT&
         iter_split(
             SequenceSequenceT& Result,
-            CollectionT& Input,
+            RangeT& Input,
             FinderT Finder )
         {
             function_requires< 
                 FinderConcept<FinderT,
-                BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type> >();
+                BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type> >();
 
             typedef BOOST_STRING_TYPENAME 
-                range_result_iterator<CollectionT>::type input_iterator_type;
+                range_result_iterator<RangeT>::type input_iterator_type;
             typedef split_iterator<input_iterator_type> find_iterator_type;
             typedef detail::copy_iterator_rangeF<
                 BOOST_STRING_TYPENAME 
diff --git a/include/boost/algorithm/string/predicate.hpp b/include/boost/algorithm/string/predicate.hpp
index 257f974..98dae62 100644
--- a/include/boost/algorithm/string/predicate.hpp
+++ b/include/boost/algorithm/string/predicate.hpp
@@ -38,7 +38,7 @@ namespace boost {
 
         //! 'Starts with' predicate
         /*!
-            This predicate holds when the test collection is a prefix of the Input.
+            This predicate holds when the test string is a prefix of the Input.
             In other words, if the input starts with the test.
             When the optional predicate is specified, it is used for character-wise
             comparison.
@@ -50,16 +50,16 @@ namespace boost {
 
               \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T, typename PredicateT>
+        template<typename Range1T, typename Range2T, typename PredicateT>
             inline bool starts_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             PredicateT Comp)
         {
             typedef BOOST_STRING_TYPENAME 
-                range_const_iterator<Collection1T>::type Iterator1T;
+                range_const_iterator<Range1T>::type Iterator1T;
             typedef BOOST_STRING_TYPENAME 
-                range_const_iterator<Collection2T>::type Iterator2T;
+                range_const_iterator<Range2T>::type Iterator2T;
 
             Iterator1T InputEnd=end(Input);
             Iterator2T TestEnd=end(Test);
@@ -81,17 +81,17 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool starts_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test)
+            const Range1T& Input, 
+            const Range2T& Test)
         {
             return starts_with(Input, Test, is_equal());
         }
 
         //! 'Starts with' predicate ( case insensitive )
         /*!
-            This predicate holds when the test container is a prefix of the Input.
+            This predicate holds when the test string is a prefix of the Input.
             In other words, if the input starts with the test.
             Elements are compared case insensitively.
 
@@ -102,10 +102,10 @@ namespace boost {
 
             \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool istarts_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
             return starts_with(Input, Test, is_iequal(Loc));
@@ -116,7 +116,7 @@ namespace boost {
 
         //! 'Ends with' predicate
         /*!
-            This predicate holds when the test container is a suffix of the Input.
+            This predicate holds when the test string is a suffix of the Input.
             In other words, if the input ends with the test.
             When the optional predicate is specified, it is used for character-wise
             comparison.
@@ -129,14 +129,14 @@ namespace boost {
 
               \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T, typename PredicateT>
+        template<typename Range1T, typename Range2T, typename PredicateT>
         inline bool ends_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             PredicateT Comp)
         {
             typedef BOOST_STRING_TYPENAME 
-                range_const_iterator<Collection1T>::type Iterator1T;
+                range_const_iterator<Range1T>::type Iterator1T;
             typedef BOOST_STRING_TYPENAME boost::detail::
                 iterator_traits<Iterator1T>::iterator_category category;
 
@@ -155,10 +155,10 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool ends_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test)
+            const Range1T& Input, 
+            const Range2T& Test)
         {
             return ends_with(Input, Test, is_equal());
         }
@@ -176,10 +176,10 @@ namespace boost {
 
             \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool iends_with( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
             return ends_with(Input, Test, is_iequal(Loc));
@@ -200,10 +200,10 @@ namespace boost {
 
                \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T, typename PredicateT>
+        template<typename Range1T, typename Range2T, typename PredicateT>
         inline bool contains( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             PredicateT Comp)
         {
             if (empty(Test))
@@ -221,10 +221,10 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool contains( 
-            const Collection1T& Input, 
-            const Collection2T& Test)
+            const Range1T& Input, 
+            const Range2T& Test)
         {
             return contains(Input, Test, is_equal());
         }
@@ -241,10 +241,10 @@ namespace boost {
 
             \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool icontains( 
-            const Collection1T& Input, 
-            const Collection2T& Test, 
+            const Range1T& Input, 
+            const Range2T& Test, 
             const std::locale& Loc=std::locale())
         {
             return contains(Input, Test, is_iequal(Loc));
@@ -268,16 +268,16 @@ namespace boost {
 
             \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T, typename PredicateT>
+        template<typename Range1T, typename Range2T, typename PredicateT>
         inline bool equals( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             PredicateT Comp)
         {
             typedef BOOST_STRING_TYPENAME 
-                range_const_iterator<Collection1T>::type Iterator1T;
+                range_const_iterator<Range1T>::type Iterator1T;
             typedef BOOST_STRING_TYPENAME 
-                range_const_iterator<Collection2T>::type Iterator2T;
+                range_const_iterator<Range2T>::type Iterator2T;
                 
             Iterator1T InputEnd=end(Input);
             Iterator2T TestEnd=end(Test);
@@ -299,10 +299,10 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool equals( 
-            const Collection1T& Input, 
-            const Collection2T& Test)
+            const Range1T& Input, 
+            const Range2T& Test)
         {
             return equals(Input, Test, is_equal());
         }
@@ -322,10 +322,10 @@ namespace boost {
 
             \note This function provides the strong exception-safety guarantee
         */
-        template<typename Collection1T, typename Collection2T>
+        template<typename Range1T, typename Range2T>
         inline bool iequals( 
-            const Collection1T& Input, 
-            const Collection2T& Test,
+            const Range1T& Input, 
+            const Range2T& Test,
             const std::locale& Loc=std::locale())
         {
             return equals(Input, Test, is_iequal(Loc));
@@ -344,13 +344,13 @@ namespace boost {
 
             \note This function provides the strong exception-safety guarantee
         */
-        template<typename CollectionT, typename PredicateT>
+        template<typename RangeT, typename PredicateT>
         inline bool all( 
-            const CollectionT& Input, 
+            const RangeT& Input, 
             PredicateT Pred)
         {
             typedef BOOST_STRING_TYPENAME 
-                range_const_iterator<CollectionT>::type Iterator1T;
+                range_const_iterator<RangeT>::type Iterator1T;
 
             Iterator1T InputEnd=end(Input);
             for( Iterator1T It=begin(Input); It!=InputEnd; ++It)
diff --git a/include/boost/algorithm/string/regex.hpp b/include/boost/algorithm/string/regex.hpp
index c71b4e7..354bc13 100644
--- a/include/boost/algorithm/string/regex.hpp
+++ b/include/boost/algorithm/string/regex.hpp
@@ -41,20 +41,20 @@ namespace boost {
             \param Flags Regex options
             \return 
                 An \c iterator_range delimiting the match. 
-                Returned iterator is either \c InputContainerT::iterator or 
-                \c InputContainerT::const_iterator, depending on the constness of 
+                Returned iterator is either \c RangeT::iterator or 
+                \c RangeT::const_iterator, depending on the constness of 
                 the input parameter.
 
               \note This function provides the strong exception-safety guarantee
         */
         template< 
-            typename CollectionT, 
+            typename RangeT, 
             typename CharT, 
             typename RegexTraitsT>
         inline iterator_range< 
-            BOOST_STRING_TYPENAME range_result_iterator<CollectionT>::type >
+            BOOST_STRING_TYPENAME range_result_iterator<RangeT>::type >
         find_regex( 
-            CollectionT& Input, 
+            RangeT& Input, 
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
@@ -83,13 +83,13 @@ namespace boost {
         */
         template< 
             typename OutputIteratorT,
-            typename CollectionT, 
+            typename RangeT, 
             typename CharT, 
             typename RegexTraitsT,
             typename FormatStringTraitsT, typename FormatStringAllocatorT >
         inline OutputIteratorT replace_regex_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             const basic_regex<CharT, RegexTraitsT>& Rx,
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
@@ -169,13 +169,13 @@ namespace boost {
         */
         template< 
             typename OutputIteratorT,
-            typename CollectionT, 
+            typename RangeT, 
             typename CharT, 
             typename RegexTraitsT,
             typename FormatStringTraitsT, typename FormatStringAllocatorT >
         inline OutputIteratorT replace_all_regex_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             const basic_regex<CharT, RegexTraitsT>& Rx,
             const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format,
             match_flag_type Flags=match_default | format_default )
@@ -254,12 +254,12 @@ namespace boost {
        */
         template< 
             typename OutputIteratorT,
-            typename CollectionT, 
+            typename RangeT, 
             typename CharT, 
             typename RegexTraitsT >
         inline OutputIteratorT erase_regex_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
@@ -333,12 +333,12 @@ namespace boost {
         */
         template< 
             typename OutputIteratorT,
-            typename CollectionT, 
+            typename RangeT, 
             typename CharT, 
             typename RegexTraitsT >
         inline OutputIteratorT erase_all_regex_copy(
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
@@ -418,12 +418,12 @@ namespace boost {
         */
         template< 
             typename SequenceSequenceT, 
-            typename CollectionT,         
+            typename RangeT,         
             typename CharT, 
             typename RegexTraitsT >
         inline SequenceSequenceT& find_all_regex(
             SequenceSequenceT& Result,
-            const CollectionT& Input,
+            const RangeT& Input,
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
@@ -459,12 +459,12 @@ namespace boost {
         */
         template< 
             typename SequenceSequenceT, 
-            typename CollectionT,         
+            typename RangeT,         
             typename CharT, 
             typename RegexTraitsT >
         inline SequenceSequenceT& split_regex(
             SequenceSequenceT& Result,
-            const CollectionT& Input,
+            const RangeT& Input,
             const basic_regex<CharT, RegexTraitsT>& Rx,
             match_flag_type Flags=match_default )
         {
diff --git a/include/boost/algorithm/string/replace.hpp b/include/boost/algorithm/string/replace.hpp
index d613686..768aa3d 100644
--- a/include/boost/algorithm/string/replace.hpp
+++ b/include/boost/algorithm/string/replace.hpp
@@ -50,15 +50,15 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT replace_range_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
+            const Range1T& Input,
             const iterator_range<
                 BOOST_STRING_TYPENAME 
-                    range_const_iterator<Collection1T>::type>& SearchRange,
-            const Collection2T& Format)
+                    range_const_iterator<Range1T>::type>& SearchRange,
+            const Range2T& Format)
         {
             return find_format_copy(
                 Output,
@@ -71,13 +71,13 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT replace_range_copy( 
             const SequenceT& Input,
             const iterator_range<
                 BOOST_STRING_TYPENAME 
                     range_const_iterator<SequenceT>::type>& SearchRange,
-            const CollectionT& Format)
+            const RangeT& Format)
         {
             return find_format_copy(
                 Input,
@@ -94,13 +94,13 @@ namespace boost {
             \param SearchRange A range in the input to be substituted
             \param Format A substitute string
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void replace_range( 
             SequenceT& Input,
             const iterator_range<
                 BOOST_STRING_TYPENAME 
                     range_iterator<SequenceT>::type>& SearchRange,
-            const CollectionT& Format)
+            const RangeT& Format)
         {
             find_format(
                 Input,
@@ -128,14 +128,14 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T,
-            typename Collection3T>
+            typename Range1T, 
+            typename Range2T,
+            typename Range3T>
         inline OutputIteratorT replace_first_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
-            const Collection3T& Format)
+            const Range1T& Input,
+            const Range2T& Search,
+            const Range3T& Format)
         {
             return find_format_copy(
                 Output,
@@ -148,11 +148,11 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline SequenceT replace_first_copy( 
             const SequenceT& Input,
-            const Collection1T& Search,
-            const Collection2T& Format )
+            const Range1T& Search,
+            const Range2T& Format )
         {
             return find_format_copy( 
                 Input,
@@ -169,11 +169,11 @@ namespace boost {
             \param Search A substring to be searched for 
             \param Format A substitute string
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline void replace_first( 
             SequenceT& Input,
-            const Collection1T& Search,
-            const Collection2T& Format )
+            const Range1T& Search,
+            const Range2T& Format )
         {
             find_format( 
                 Input, 
@@ -203,14 +203,14 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T,
-            typename Collection3T>
+            typename Range1T, 
+            typename Range2T,
+            typename Range3T>
         inline OutputIteratorT ireplace_first_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
-            const Collection3T& Format,
+            const Range1T& Input,
+            const Range2T& Search,
+            const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy(
@@ -224,11 +224,11 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename Collection2T, typename Collection1T>
+        template<typename SequenceT, typename Range2T, typename Range1T>
         inline SequenceT ireplace_first_copy( 
             const SequenceT& Input,
-            const Collection2T& Search,
-            const Collection1T& Format,
+            const Range2T& Search,
+            const Range1T& Format,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy( 
@@ -248,11 +248,11 @@ namespace boost {
             \param Format A substitute string
             \param Loc A locale used for case insensitive comparison
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline void ireplace_first( 
             SequenceT& Input,
-            const Collection1T& Search,
-            const Collection2T& Format,
+            const Range1T& Search,
+            const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
             find_format( 
@@ -281,14 +281,14 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T,
-            typename Collection3T>
+            typename Range1T, 
+            typename Range2T,
+            typename Range3T>
         inline OutputIteratorT replace_last_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
-            const Collection3T& Format )
+            const Range1T& Input,
+            const Range2T& Search,
+            const Range3T& Format )
         {
             return find_format_copy(
                 Output,
@@ -301,11 +301,11 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline SequenceT replace_last_copy( 
             const SequenceT& Input,
-            const Collection1T& Search,
-            const Collection2T& Format )
+            const Range1T& Search,
+            const Range2T& Format )
         {
             return find_format_copy( 
                 Input,
@@ -322,11 +322,11 @@ namespace boost {
             \param Search A substring to be searched for 
             \param Format A substitute string
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline void replace_last( 
             SequenceT& Input,
-            const Collection1T& Search,
-            const Collection2T& Format )
+            const Range1T& Search,
+            const Range2T& Format )
         {
             find_format( 
                 Input, 
@@ -356,14 +356,14 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T,
-            typename Collection3T>
+            typename Range1T, 
+            typename Range2T,
+            typename Range3T>
         inline OutputIteratorT ireplace_last_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
-            const Collection3T& Format,
+            const Range1T& Input,
+            const Range2T& Search,
+            const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy(
@@ -377,11 +377,11 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline SequenceT ireplace_last_copy( 
             const SequenceT& Input,
-            const Collection1T& Search,
-            const Collection2T& Format,
+            const Range1T& Search,
+            const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy( 
@@ -402,11 +402,11 @@ namespace boost {
             \param Loc A locale used for case insensitive comparison
             \return A reference to the modified input
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline void ireplace_last( 
             SequenceT& Input,
-            const Collection1T& Search,
-            const Collection2T& Format,
+            const Range1T& Search,
+            const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
             find_format( 
@@ -436,15 +436,15 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T,
-            typename Collection3T>
+            typename Range1T, 
+            typename Range2T,
+            typename Range3T>
         inline OutputIteratorT replace_nth_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             unsigned int Nth,
-            const Collection3T& Format )
+            const Range3T& Format )
         {
             return find_format_copy(
                 Output,
@@ -457,12 +457,12 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline SequenceT replace_nth_copy( 
             const SequenceT& Input,
-            const Collection1T& Search,
+            const Range1T& Search,
             unsigned int Nth,
-            const Collection2T& Format )
+            const Range2T& Format )
         {
             return find_format_copy( 
                 Input,
@@ -480,12 +480,12 @@ namespace boost {
             \param Nth An index of the match to be replaced. The index is 0-based.
             \param Format A substitute string
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline void replace_nth( 
             SequenceT& Input,
-            const Collection1T& Search,
+            const Range1T& Search,
             unsigned int Nth,
-            const Collection2T& Format )
+            const Range2T& Format )
         {
             find_format( 
                 Input, 
@@ -516,15 +516,15 @@ namespace boost {
        */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T,
-            typename Collection3T>
+            typename Range1T, 
+            typename Range2T,
+            typename Range3T>
         inline OutputIteratorT ireplace_nth_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
+            const Range1T& Input,
+            const Range2T& Search,
             unsigned int Nth,
-            const Collection3T& Format,
+            const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy(
@@ -538,12 +538,12 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline SequenceT ireplace_nth_copy( 
             const SequenceT& Input,
-            const Collection1T& Search,
+            const Range1T& Search,
             unsigned int Nth,
-            const Collection2T& Format,
+            const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
             return find_format_copy( 
@@ -564,12 +564,12 @@ namespace boost {
             \param Format A substitute string
             \param Loc A locale used for case insensitive comparison
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline void ireplace_nth( 
             SequenceT& Input,
-            const Collection1T& Search,
+            const Range1T& Search,
             unsigned int Nth,
-            const Collection2T& Format,
+            const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
             find_format( 
@@ -598,14 +598,14 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T,
-            typename Collection3T>
+            typename Range1T, 
+            typename Range2T,
+            typename Range3T>
         inline OutputIteratorT replace_all_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
-            const Collection3T& Format )
+            const Range1T& Input,
+            const Range2T& Search,
+            const Range3T& Format )
         {
             return find_format_all_copy(
                 Output,
@@ -618,11 +618,11 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline SequenceT replace_all_copy( 
             const SequenceT& Input,
-            const Collection1T& Search,
-            const Collection2T& Format )
+            const Range1T& Search,
+            const Range2T& Format )
         {
             return find_format_all_copy( 
                 Input,
@@ -640,11 +640,11 @@ namespace boost {
             \param Format A substitute string
             \return A reference to the modified input
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline void replace_all( 
             SequenceT& Input,
-            const Collection1T& Search,
-            const Collection2T& Format )
+            const Range1T& Search,
+            const Range2T& Format )
         {
             find_format_all( 
                 Input, 
@@ -674,14 +674,14 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T,
-            typename Collection3T>
+            typename Range1T, 
+            typename Range2T,
+            typename Range3T>
         inline OutputIteratorT ireplace_all_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
-            const Collection2T& Search,
-            const Collection3T& Format,
+            const Range1T& Input,
+            const Range2T& Search,
+            const Range3T& Format,
             const std::locale& Loc=std::locale() )
         {
             return find_format_all_copy(
@@ -695,11 +695,11 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline SequenceT ireplace_all_copy( 
             const SequenceT& Input,
-            const Collection1T& Search,
-            const Collection2T& Format,
+            const Range1T& Search,
+            const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
             return find_format_all_copy( 
@@ -719,11 +719,11 @@ namespace boost {
             \param Format A substitute string
             \param Loc A locale used for case insensitive comparison
         */
-        template<typename SequenceT, typename Collection1T, typename Collection2T>
+        template<typename SequenceT, typename Range1T, typename Range2T>
         inline void ireplace_all( 
             SequenceT& Input,
-            const Collection1T& Search,
-            const Collection2T& Format,
+            const Range1T& Search,
+            const Range2T& Format,
             const std::locale& Loc=std::locale() )
         {
             find_format_all( 
@@ -754,13 +754,13 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT replace_head_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
+            const Range1T& Input,
             unsigned int N,
-            const Collection2T& Format )
+            const Range2T& Format )
         {
             return find_format_copy(
                 Output,
@@ -773,11 +773,11 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT replace_head_copy( 
             const SequenceT& Input,
             unsigned int N,
-            const CollectionT& Format )
+            const RangeT& Format )
         {
             return find_format_copy( 
                 Input,
@@ -796,11 +796,11 @@ namespace boost {
             \param N Length of the head
             \param Format A substitute string
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void replace_head( 
             SequenceT& Input,
             unsigned int N,
-            const CollectionT& Format )
+            const RangeT& Format )
         {
             find_format( 
                 Input, 
@@ -830,13 +830,13 @@ namespace boost {
         */
         template<
             typename OutputIteratorT,
-            typename Collection1T, 
-            typename Collection2T>
+            typename Range1T, 
+            typename Range2T>
         inline OutputIteratorT replace_tail_copy(
             OutputIteratorT Output,
-            const Collection1T& Input,
+            const Range1T& Input,
             unsigned int N,
-            const Collection2T& Format )
+            const Range2T& Format )
         {
             return find_format_copy(
                 Output,
@@ -849,11 +849,11 @@ namespace boost {
         /*!
             \overload
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline SequenceT replace_tail_copy( 
             const SequenceT& Input,
             unsigned int N,
-            const CollectionT& Format )
+            const RangeT& Format )
         {
             return find_format_copy( 
                 Input,
@@ -872,11 +872,11 @@ namespace boost {
             \param N Length of the tail
             \param Format A substitute string
         */
-        template<typename SequenceT, typename CollectionT>
+        template<typename SequenceT, typename RangeT>
         inline void replace_tail( 
             SequenceT& Input,
             unsigned int N,
-            const CollectionT& Format )
+            const RangeT& Format )
         {
             find_format( 
                 Input, 
diff --git a/include/boost/algorithm/string/split.hpp b/include/boost/algorithm/string/split.hpp
index a701efc..b5c6ff9 100644
--- a/include/boost/algorithm/string/split.hpp
+++ b/include/boost/algorithm/string/split.hpp
@@ -57,11 +57,11 @@ namespace boost {
 
                \note This function provides the strong exception-safety guarantee
         */
-        template< typename SequenceSequenceT, typename Collection1T, typename Collection2T >
+        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
         inline SequenceSequenceT& find_all(
             SequenceSequenceT& Result,
-            Collection1T& Input,
-            const Collection2T& Search)
+            Range1T& Input,
+            const Range2T& Search)
         {
             return iter_find(
                 Result,
@@ -92,11 +92,11 @@ namespace boost {
 
               \note This function provides the strong exception-safety guarantee
         */
-        template< typename SequenceSequenceT, typename Collection1T, typename Collection2T >
+        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
         inline SequenceSequenceT& ifind_all(
             SequenceSequenceT& Result,
-            Collection1T& Input,
-            const Collection2T& Search,
+            Range1T& Input,
+            const Range2T& Search,
             const std::locale& Loc=std::locale() )
         {
             return iter_find(
@@ -135,10 +135,10 @@ namespace boost {
 
             \note This function provides the strong exception-safety guarantee
         */
-        template< typename SequenceSequenceT, typename CollectionT, typename PredicateT >
+        template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
         inline SequenceSequenceT& split(
             SequenceSequenceT& Result,
-            CollectionT& Input,
+            RangeT& Input,
             PredicateT Pred,
             token_compress_mode_type eCompress=token_compress_off )
         {
diff --git a/include/boost/algorithm/string/trim.hpp b/include/boost/algorithm/string/trim.hpp
index cc14c5d..8c21e65 100644
--- a/include/boost/algorithm/string/trim.hpp
+++ b/include/boost/algorithm/string/trim.hpp
@@ -54,10 +54,10 @@ namespace boost {
 
                \note The second variant of this function provides the strong exception-safety guarantee
         */
-        template<typename OutputIteratorT, typename CollectionT, typename PredicateT>
+        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
         inline OutputIteratorT trim_left_copy_if( 
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             PredicateT IsSpace)
         {
             std::copy( 
@@ -160,10 +160,10 @@ namespace boost {
 
              \note The second variant of this function provides the strong exception-safety guarantee
         */
-        template<typename OutputIteratorT, typename CollectionT, typename PredicateT>
+        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
         inline OutputIteratorT trim_right_copy_if( 
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             PredicateT IsSpace )
         {
             std::copy( 
@@ -270,14 +270,14 @@ namespace boost {
 
              \note The second variant of this function provides the strong exception-safety guarantee
         */
-        template<typename OutputIteratorT, typename CollectionT, typename PredicateT>
+        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
         inline OutputIteratorT trim_copy_if( 
             OutputIteratorT Output,
-            const CollectionT& Input,
+            const RangeT& Input,
             PredicateT IsSpace)
         {
             BOOST_STRING_TYPENAME 
-                range_const_iterator<CollectionT>::type TrimEnd=
+                range_const_iterator<RangeT>::type TrimEnd=
                 detail::trim_end( 
                     begin(Input), 
                     end(Input),