add case_conv algorithms

sprout/algorithm/fixed/remove.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_ALGORITHM_FIXED_REMOVE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/remove_copy.hpp>

sprout/algorithm/fixed/remove_if.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_ALGORITHM_FIXED_REMOVE_IF_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/remove_copy_if.hpp>

sprout/algorithm/fixed/replace.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_ALGORITHM_FIXED_REPLACE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/replace_copy.hpp>

sprout/algorithm/fixed/replace_if.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_ALGORITHM_FIXED_REPLACE_IF_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/replace_copy_if.hpp>

sprout/algorithm/fixed/reverse.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_ALGORITHM_FIXED_REVERSE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/reverse_copy.hpp>

sprout/algorithm/fixed/unique.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_ALGORITHM_FIXED_UNIQUE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/unique_copy.hpp>
 

sprout/algorithm/string.hpp

@@ -3,5 +3,6 @@
 
 #include <sprout/config.hpp>
 #include <sprout/algorithm/string/join.hpp>
+#include <sprout/algorithm/string/case_conv.hpp>
 
 #endif	// #ifndef SPROUT_ALGORITHM_STRING_HPP

sprout/algorithm/string/case_conv.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_ALGORITHM_STRING_CASE_CONV_HPP
+#define SPROUT_ALGORITHM_STRING_CASE_CONV_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/algorithm/string/fixed/case_conv.hpp>
+#include <sprout/algorithm/string/fit/case_conv.hpp>
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_CASE_CONV_HPP

sprout/algorithm/string/fit/case_conv.hpp

@@ -0,0 +1,10 @@
+#ifndef SPROUT_ALGORITHM_STRING_FIT_CASE_CONV_HPP
+#define SPROUT_ALGORITHM_STRING_FIT_CASE_CONV_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/algorithm/string/fit/to_lower_copy.hpp>
+#include <sprout/algorithm/string/fit/to_upper_copy.hpp>
+#include <sprout/algorithm/string/fit/to_lower.hpp>
+#include <sprout/algorithm/string/fit/to_upper.hpp>
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_FIT_CASE_CONV_HPP

sprout/algorithm/string/fit/to_lower.hpp

@@ -0,0 +1,46 @@
+#ifndef SPROUT_ALGORITHM_STRING_FIT_TO_LOWER_HPP
+#define SPROUT_ALGORITHM_STRING_FIT_TO_LOWER_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/algorithm/string/fixed/to_lower.hpp>
+#include <sprout/algorithm/fit/result_of.hpp>
+#include <sprout/sub_array/sub_array.hpp>
+#include <sprout/sub_array/sub.hpp>
+
+namespace sprout {
+	namespace algorithm {
+		namespace fit {
+			namespace detail {
+				template<typename Container>
+				inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Container>::type
+				to_lower_impl(
+					Container const& cont,
+					typename sprout::container_traits<Container>::difference_type offset
+					)
+				{
+					return sprout::sub_copy(
+						sprout::get_internal(sprout::algorithm::fixed::to_lower(cont)),
+						offset,
+						offset + sprout::size(cont)
+						);
+				}
+			}	// namespace detail
+			//
+			// to_lower
+			//
+			template<typename Container>
+			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Container>::type
+			to_lower(Container const& cont) {
+				return sprout::algorithm::fit::detail::to_lower_impl(cont, sprout::internal_begin_offset(cont));
+			}
+		}	// namespace fit
+	}	// namespace algorithm
+
+	namespace fit {
+		using sprout::algorithm::fit::to_lower;
+	}	// namespace fit
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_FIT_TO_LOWER_HPP

sprout/algorithm/string/fit/to_lower_copy.hpp

@@ -0,0 +1,49 @@
+#ifndef SPROUT_ALGORITHM_STRING_FIT_TO_LOWER_COPY_HPP
+#define SPROUT_ALGORITHM_STRING_FIT_TO_LOWER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/iterator/distance.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/algorithm/string/fixed/to_lower_copy.hpp>
+#include <sprout/algorithm/fit/result_of.hpp>
+#include <sprout/sub_array/sub_array.hpp>
+#include <sprout/sub_array/sub.hpp>
+#include <sprout/iterator/type_traits/category.hpp>
+
+namespace sprout {
+	namespace algorithm {
+		namespace fit {
+			namespace detail {
+				template<typename InputIterator, typename Result>
+				inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
+				to_lower_copy_impl(
+					InputIterator first, InputIterator last, Result const& result,
+					typename sprout::container_traits<Result>::difference_type offset
+					)
+				{
+					return sprout::sub_copy(
+						sprout::get_internal(sprout::algorithm::fixed::to_lower_copy(first, last, result)),
+						offset,
+						offset + sprout::fit_size(result, sprout::distance(first, last))
+						);
+				}
+			}	// namespace detail
+			//
+			// to_lower_copy
+			//
+			template<typename InputIterator, typename Result>
+			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
+			to_lower_copy(InputIterator first, InputIterator last, Result const& result) {
+				static_assert(sprout::is_forward_iterator<InputIterator>::value, "Sorry, not implemented.");
+				return sprout::algorithm::fit::detail::to_lower_copy_impl(first, last, result, sprout::internal_begin_offset(result));
+			}
+		}	// namespace fit
+	}	// namespace algorithm
+
+	namespace fit {
+		using sprout::algorithm::fit::to_lower_copy;
+	}	// namespace fit
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_FIT_TO_LOWER_COPY_HPP

sprout/algorithm/string/fit/to_upper.hpp

@@ -0,0 +1,46 @@
+#ifndef SPROUT_ALGORITHM_STRING_FIT_TO_UPPER_HPP
+#define SPROUT_ALGORITHM_STRING_FIT_TO_UPPER_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/algorithm/string/fixed/to_upper.hpp>
+#include <sprout/algorithm/fit/result_of.hpp>
+#include <sprout/sub_array/sub_array.hpp>
+#include <sprout/sub_array/sub.hpp>
+
+namespace sprout {
+	namespace algorithm {
+		namespace fit {
+			namespace detail {
+				template<typename Container>
+				inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Container>::type
+				to_upper_impl(
+					Container const& cont,
+					typename sprout::container_traits<Container>::difference_type offset
+					)
+				{
+					return sprout::sub_copy(
+						sprout::get_internal(sprout::algorithm::fixed::to_upper(cont)),
+						offset,
+						offset + sprout::size(cont)
+						);
+				}
+			}	// namespace detail
+			//
+			// to_upper
+			//
+			template<typename Container>
+			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Container>::type
+			to_upper(Container const& cont) {
+				return sprout::algorithm::fit::detail::to_upper_impl(cont, sprout::internal_begin_offset(cont));
+			}
+		}	// namespace fit
+	}	// namespace algorithm
+
+	namespace fit {
+		using sprout::algorithm::fit::to_upper;
+	}	// namespace fit
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_FIT_TO_UPPER_HPP

sprout/algorithm/string/fit/to_upper_copy.hpp

@@ -0,0 +1,49 @@
+#ifndef SPROUT_ALGORITHM_STRING_FIT_TO_UPPER_COPY_HPP
+#define SPROUT_ALGORITHM_STRING_FIT_TO_UPPER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/iterator/distance.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/algorithm/string/fixed/to_upper_copy.hpp>
+#include <sprout/algorithm/fit/result_of.hpp>
+#include <sprout/sub_array/sub_array.hpp>
+#include <sprout/sub_array/sub.hpp>
+#include <sprout/iterator/type_traits/category.hpp>
+
+namespace sprout {
+	namespace algorithm {
+		namespace fit {
+			namespace detail {
+				template<typename InputIterator, typename Result>
+				inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
+				to_upper_copy_impl(
+					InputIterator first, InputIterator last, Result const& result,
+					typename sprout::container_traits<Result>::difference_type offset
+					)
+				{
+					return sprout::sub_copy(
+						sprout::get_internal(sprout::algorithm::fixed::to_upper_copy(first, last, result)),
+						offset,
+						offset + sprout::fit_size(result, sprout::distance(first, last))
+						);
+				}
+			}	// namespace detail
+			//
+			// to_upper_copy
+			//
+			template<typename InputIterator, typename Result>
+			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
+			to_upper_copy(InputIterator first, InputIterator last, Result const& result) {
+				static_assert(sprout::is_forward_iterator<InputIterator>::value, "Sorry, not implemented.");
+				return sprout::algorithm::fit::detail::to_upper_copy_impl(first, last, result, sprout::internal_begin_offset(result));
+			}
+		}	// namespace fit
+	}	// namespace algorithm
+
+	namespace fit {
+		using sprout::algorithm::fit::to_upper_copy;
+	}	// namespace fit
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_FIT_TO_UPPER_COPY_HPP

sprout/algorithm/string/fixed/case_conv.hpp

@@ -0,0 +1,10 @@
+#ifndef SPROUT_ALGORITHM_STRING_FIXED_CASE_CONV_HPP
+#define SPROUT_ALGORITHM_STRING_FIXED_CASE_CONV_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/algorithm/string/fixed/to_lower_copy.hpp>
+#include <sprout/algorithm/string/fixed/to_upper_copy.hpp>
+#include <sprout/algorithm/string/fixed/to_lower.hpp>
+#include <sprout/algorithm/string/fixed/to_upper.hpp>
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_FIXED_CASE_CONV_HPP

sprout/algorithm/string/fixed/to_lower.hpp

@@ -0,0 +1,32 @@
+#ifndef SPROUT_ALGORITHM_STRING_FIXED_TO_LOWER_HPP
+#define SPROUT_ALGORITHM_STRING_FIXED_TO_LOWER_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/algorithm/string/fixed/to_lower_copy.hpp>
+
+namespace sprout {
+	namespace algorithm {
+		namespace fixed {
+			//
+			// to_lower
+			//
+			template<typename Container>
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
+			to_lower(Container const& cont) {
+				return sprout::algorithm::fixed::to_lower_copy(sprout::begin(cont), sprout::end(cont), cont);
+			}
+		}	// namespace fixed
+
+		using sprout::algorithm::fixed::to_lower;
+	}	// namespace algorithm
+
+	namespace fixed {
+		using sprout::algorithm::fixed::to_lower;
+	}	// namespace fixed
+
+	using sprout::algorithm::fixed::to_lower;
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_FIXED_TO_LOWER_HPP

sprout/algorithm/string/fixed/to_lower_copy.hpp

@@ -0,0 +1,39 @@
+#ifndef SPROUT_ALGORITHM_STRING_FIXED_TO_LOWER_COPY_HPP
+#define SPROUT_ALGORITHM_STRING_FIXED_TO_LOWER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/algorithm/fixed/transform.hpp>
+#include <sprout/pit/pit.hpp>
+#include <sprout/ctype/functor.hpp>
+
+namespace sprout {
+	namespace algorithm {
+		namespace fixed {
+			//
+			// to_lower_copy
+			//
+			template<typename InputIterator, typename Result>
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+			to_lower_copy(InputIterator first, InputIterator last, Result const& result) {
+				return sprout::fixed::transform(first, last, sprout::ctypes::to_lower<>(), result);
+			}
+
+			template<typename Result, typename InputIterator>
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+			to_lower_copy(InputIterator first, InputIterator last) {
+				return sprout::algorithm::fixed::to_lower_copy(first, last, sprout::pit<Result>());
+			}
+		}	// namespace fixed
+
+		using sprout::algorithm::fixed::to_lower_copy;
+	}	// namespace algorithm
+
+	namespace fixed {
+		using sprout::algorithm::fixed::to_lower_copy;
+	}	// namespace fixed
+
+	using sprout::algorithm::fixed::to_lower_copy;
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_FIXED_TO_LOWER_COPY_HPP

sprout/algorithm/string/fixed/to_upper.hpp

@@ -0,0 +1,32 @@
+#ifndef SPROUT_ALGORITHM_STRING_FIXED_TO_UPPER_HPP
+#define SPROUT_ALGORITHM_STRING_FIXED_TO_UPPER_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/algorithm/string/fixed/to_upper_copy.hpp>
+
+namespace sprout {
+	namespace algorithm {
+		namespace fixed {
+			//
+			// to_upper
+			//
+			template<typename Container>
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
+			to_upper(Container const& cont) {
+				return sprout::algorithm::fixed::to_upper_copy(sprout::begin(cont), sprout::end(cont), cont);
+			}
+		}	// namespace fixed
+
+		using sprout::algorithm::fixed::to_upper;
+	}	// namespace algorithm
+
+	namespace fixed {
+		using sprout::algorithm::fixed::to_upper;
+	}	// namespace fixed
+
+	using sprout::algorithm::fixed::to_upper;
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_FIXED_TO_UPPER_HPP

sprout/algorithm/string/fixed/to_upper_copy.hpp

@@ -0,0 +1,39 @@
+#ifndef SPROUT_ALGORITHM_STRING_FIXED_TO_UPPER_COPY_HPP
+#define SPROUT_ALGORITHM_STRING_FIXED_TO_UPPER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/algorithm/fixed/transform.hpp>
+#include <sprout/pit/pit.hpp>
+#include <sprout/ctype/functor.hpp>
+
+namespace sprout {
+	namespace algorithm {
+		namespace fixed {
+			//
+			// to_upper_copy
+			//
+			template<typename InputIterator, typename Result>
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+			to_upper_copy(InputIterator first, InputIterator last, Result const& result) {
+				return sprout::fixed::transform(first, last, sprout::ctypes::to_upper<>(), result);
+			}
+
+			template<typename Result, typename InputIterator>
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+			to_upper_copy(InputIterator first, InputIterator last) {
+				return sprout::algorithm::fixed::to_upper_copy(first, last, sprout::pit<Result>());
+			}
+		}	// namespace fixed
+
+		using sprout::algorithm::fixed::to_upper_copy;
+	}	// namespace algorithm
+
+	namespace fixed {
+		using sprout::algorithm::fixed::to_upper_copy;
+	}	// namespace fixed
+
+	using sprout::algorithm::fixed::to_upper_copy;
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_FIXED_TO_UPPER_COPY_HPP

sprout/algorithm/string/to_lower.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_ALGORITHM_STRING_TO_LOWER_HPP
+#define SPROUT_ALGORITHM_STRING_TO_LOWER_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/algorithm/string/fixed/to_lower.hpp>
+#include <sprout/algorithm/string/fit/to_lower.hpp>
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_TO_LOWER_HPP

sprout/algorithm/string/to_lower_copy.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_ALGORITHM_STRING_TO_LOWER_COPY_HPP
+#define SPROUT_ALGORITHM_STRING_TO_LOWER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/algorithm/string/fixed/to_lower_copy.hpp>
+#include <sprout/algorithm/string/fit/to_lower_copy.hpp>
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_TO_LOWER_COPY_HPP

sprout/algorithm/string/to_upper.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_ALGORITHM_STRING_TO_UPPER_HPP
+#define SPROUT_ALGORITHM_STRING_TO_UPPER_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/algorithm/string/fixed/to_upper.hpp>
+#include <sprout/algorithm/string/fit/to_upper.hpp>
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_TO_UPPER_HPP

sprout/algorithm/string/to_upper_copy.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_ALGORITHM_STRING_TO_UPPER_COPY_HPP
+#define SPROUT_ALGORITHM_STRING_TO_UPPER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/algorithm/string/fixed/to_upper_copy.hpp>
+#include <sprout/algorithm/string/fit/to_upper_copy.hpp>
+
+#endif	// #ifndef SPROUT_ALGORITHM_STRING_TO_UPPER_COPY_HPP

sprout/ctype.hpp

@@ -2,7 +2,9 @@
 #define SPROUT_CTYPE_HPP
 
 #include <sprout/config.hpp>
+#include <sprout/ctype/mask.hpp>
 #include <sprout/ctype/ascii.hpp>
 #include <sprout/ctype/wascii.hpp>
+#include <sprout/ctype/functor.hpp>
 
 #endif	// #ifndef SPROUT_CTYPE_HPP

sprout/ctype/ascii.hpp

@@ -5,6 +5,7 @@
 #include <sprout/config.hpp>
 #include <sprout/preprocessor/cat.hpp>
 #include <sprout/preprocessor/empty.hpp>
+#include <sprout/ctype/mask.hpp>
 
 namespace sprout {
 	namespace ascii {
@@ -235,6 +236,22 @@ namespace sprout {
 		inline SPROUT_CONSTEXPR CHAR_TYPE \
 		SPROUT_PP_CAT(to, SPROUT_PP_CAT(PREFIX, upper))(CHAR_TYPE c) { \
 			return sprout::ascii::detail::get_value(c) & sprout::ascii::detail::upper ? c - (0x61 - 0x41) : c; \
+		} \
+		inline SPROUT_CONSTEXPR bool \
+		SPROUT_PP_CAT(is, SPROUT_PP_CAT(PREFIX, classified))(sprout::ctypes::mask_t m, CHAR_TYPE c) { \
+			return (m | sprout::ctypes::alnum && (sprout::ascii::detail::get_value(c) & (sprout::ascii::detail::alpha | sprout::ascii::detail::digit))) \
+				|| (m | sprout::ctypes::alpha && (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::alpha)) \
+				|| (m | sprout::ctypes::blank && (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::blank)) \
+				|| (m | sprout::ctypes::cntrl && (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::cntrl)) \
+				|| (m | sprout::ctypes::digit && (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::digit)) \
+				|| (m | sprout::ctypes::graph && (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::graph)) \
+				|| (m | sprout::ctypes::lower && (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::lower)) \
+				|| (m | sprout::ctypes::print && (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::print)) \
+				|| (m | sprout::ctypes::punct && (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::punct)) \
+				|| (m | sprout::ctypes::space && (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::space)) \
+				|| (m | sprout::ctypes::upper && (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::upper)) \
+				|| (m | sprout::ctypes::xdigit && (sprout::ascii::detail::get_value(c) & sprout::ascii::detail::xdigit)) \
+				; \
 		}
 
 		//
@@ -252,6 +269,7 @@ namespace sprout {
 		// isxdigit
 		// tolower
 		// toupper
+		// isclassified
 		//
 		SPROUT_CTYPE_ASCII_DECL(char, SPROUT_PP_EMPTY())
 		SPROUT_CTYPE_ASCII_DECL(wchar_t, SPROUT_PP_EMPTY())
@@ -273,6 +291,7 @@ namespace sprout {
 	using sprout::ascii::isxdigit;
 	using sprout::ascii::tolower;
 	using sprout::ascii::toupper;
+	using sprout::ascii::isclassified;
 }	// namespace sprout
 
 #endif	// #ifndef SPROUT_CTYPE_ASCII_HPP

sprout/ctype/functor.hpp

@@ -0,0 +1,408 @@
+#ifndef SPROUT_CTYPE_FUNCTOR_HPP
+#define SPROUT_CTYPE_FUNCTOR_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/ctype/mask.hpp>
+#include <sprout/ctype/ascii.hpp>
+
+namespace sprout {
+	namespace ctypes {
+		//
+		// is_alnum
+		//
+		template<typename T = void>
+		struct is_alnum {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::isalnum(x);
+			}
+		};
+		template<>
+		struct is_alnum<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_alnum<T>()(x);
+			}
+		};
+
+		//
+		// is_alpha
+		//
+		template<typename T = void>
+		struct is_alpha {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::isalpha(x);
+			}
+		};
+		template<>
+		struct is_alpha<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_alpha<T>()(x);
+			}
+		};
+
+		//
+		// is_blank
+		//
+		template<typename T = void>
+		struct is_blank {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::isblank(x);
+			}
+		};
+		template<>
+		struct is_blank<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_blank<T>()(x);
+			}
+		};
+
+		//
+		// is_cntrl
+		//
+		template<typename T = void>
+		struct is_cntrl {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::iscntrl(x);
+			}
+		};
+		template<>
+		struct is_cntrl<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_cntrl<T>()(x);
+			}
+		};
+
+		//
+		// is_digit
+		//
+		template<typename T = void>
+		struct is_digit {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::isdigit(x);
+			}
+		};
+		template<>
+		struct is_digit<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_digit<T>()(x);
+			}
+		};
+
+		//
+		// is_graph
+		//
+		template<typename T = void>
+		struct is_graph {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::isgraph(x);
+			}
+		};
+		template<>
+		struct is_graph<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_graph<T>()(x);
+			}
+		};
+
+		//
+		// is_lower
+		//
+		template<typename T = void>
+		struct is_lower {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::islower(x);
+			}
+		};
+		template<>
+		struct is_lower<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_lower<T>()(x);
+			}
+		};
+
+		//
+		// is_print
+		//
+		template<typename T = void>
+		struct is_print {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::isprint(x);
+			}
+		};
+		template<>
+		struct is_print<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_print<T>()(x);
+			}
+		};
+
+		//
+		// is_punct
+		//
+		template<typename T = void>
+		struct is_punct {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ispunct(x);
+			}
+		};
+		template<>
+		struct is_punct<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_punct<T>()(x);
+			}
+		};
+
+		//
+		// is_space
+		//
+		template<typename T = void>
+		struct is_space {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::isspace(x);
+			}
+		};
+		template<>
+		struct is_space<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_space<T>()(x);
+			}
+		};
+
+		//
+		// is_upper
+		//
+		template<typename T = void>
+		struct is_upper {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::isupper(x);
+			}
+		};
+		template<>
+		struct is_upper<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_upper<T>()(x);
+			}
+		};
+
+		//
+		// is_xdigit
+		//
+		template<typename T = void>
+		struct is_xdigit {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		public:
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::isxdigit(x);
+			}
+		};
+		template<>
+		struct is_xdigit<void> {
+		public:
+			typedef bool result_type;
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_xdigit<T>()(x);
+			}
+		};
+
+		//
+		// to_lower
+		//
+		template<typename T = void>
+		struct to_lower {
+		public:
+			typedef T argument_type;
+			typedef T result_type;
+		public:
+			SPROUT_CONSTEXPR T
+			operator()(T const& x) const {
+				return sprout::tolower(x);
+			}
+		};
+		template<>
+		struct to_lower<void> {
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR T
+			operator()(T const& x) const {
+				return sprout::ctypes::to_lower<T>()(x);
+			}
+		};
+
+		//
+		// to_upper
+		//
+		template<typename T = void>
+		struct to_upper {
+		public:
+			typedef T argument_type;
+			typedef T result_type;
+		public:
+			SPROUT_CONSTEXPR T
+			operator()(T const& x) const {
+				return sprout::toupper(x);
+			}
+		};
+		template<>
+		struct to_upper<void> {
+		public:
+			template<typename T>
+			SPROUT_CONSTEXPR T
+			operator()(T const& x) const {
+				return sprout::ctypes::to_upper<T>()(x);
+			}
+		};
+
+		//
+		// is_classified
+		//
+		template<typename T = void>
+		struct is_classified {
+		public:
+			typedef T argument_type;
+			typedef bool result_type;
+		private:
+			sprout::ctypes::mask_t m_;
+		public:
+			explicit SPROUT_CONSTEXPR is_classified(sprout::ctypes::mask_t m)
+				: m_(m)
+			{}
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::isclassified(m_, x);
+			}
+		};
+		template<>
+		struct is_classified<void> {
+		public:
+			typedef bool result_type;
+		private:
+			sprout::ctypes::mask_t m_;
+		public:
+			explicit SPROUT_CONSTEXPR is_classified(sprout::ctypes::mask_t m)
+				: m_(m)
+			{}
+			template<typename T>
+			SPROUT_CONSTEXPR bool
+			operator()(T const& x) const {
+				return sprout::ctypes::is_classified<T>(m_)(x);
+			}
+		};
+	}	// namespace ctypes
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_CTYPE_FUNCTOR_HPP

sprout/ctype/mask.hpp

@@ -0,0 +1,43 @@
+#ifndef SPROUT_CTYPE_MASK_HPP
+#define SPROUT_CTYPE_MASK_HPP
+
+#include <locale>
+#include <sprout/config.hpp>
+
+namespace sprout {
+	namespace ctypes {
+		//
+		// mask_t
+		//
+		typedef std::ctype_base::mask mask_t;
+
+		//
+		// space
+		// print
+		// cntrl
+		// upper
+		// lower
+		// alpha
+		// digit
+		// punct
+		// xdigit
+		// blank
+		// alnum
+		// graph
+		//
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t space = std::ctype_base::space;
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t print = std::ctype_base::print;
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t cntrl = std::ctype_base::cntrl;
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t upper = std::ctype_base::upper;
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t lower = std::ctype_base::lower;
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t alpha = std::ctype_base::alpha;
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t digit = std::ctype_base::digit;
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t punct = std::ctype_base::punct;
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t xdigit = std::ctype_base::xdigit;
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t blank = /*std::ctype_base::blank*/1 << 9;
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t alnum = std::ctype_base::alnum;
+		SPROUT_STATIC_CONSTEXPR sprout::ctypes::mask_t graph = std::ctype_base::graph;
+	}	// namespace ctypes
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_CTYPE_MASK_HPP

sprout/ctype/wascii.hpp

@@ -21,6 +21,7 @@ namespace sprout {
 		// iswxdigit
 		// towlower
 		// towupper
+		// iswclassified
 		//
 		SPROUT_CTYPE_ASCII_DECL(wchar_t, w)
 	}	// namespace ascii
@@ -39,6 +40,7 @@ namespace sprout {
 	using sprout::ascii::iswxdigit;
 	using sprout::ascii::towlower;
 	using sprout::ascii::towupper;
+	using sprout::ascii::iswclassified;
 }	// namespace sprout
 
 #endif	// #ifndef SPROUT_CTYPE_WASCII_HPP

sprout/iterator/predefined.hpp

@@ -5,6 +5,7 @@
 #include <sprout/iterator/various.hpp>
 #include <sprout/iterator/adaptor.hpp>
 #include <sprout/iterator/inserter.hpp>
+#include <sprout/iterator/string.hpp>
 #include <sprout/iterator/wave.hpp>
 #include <sprout/iterator/dft.hpp>
 

sprout/iterator/string.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_ITERATOR_STRING_HPP
+#define SPROUT_ITERATOR_STRING_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/iterator/to_lower_iterator.hpp>
+#include <sprout/iterator/to_upper_iterator.hpp>
+
+#endif	// #ifndef SPROUT_ITERATOR_STRING_HPP

sprout/iterator/to_lower_iterator.hpp

@@ -0,0 +1,22 @@
+#ifndef SPROUT_ITERATOR_TO_LOWER_ITERATOR_HPP
+#define SPROUT_ITERATOR_TO_LOWER_ITERATOR_HPP
+
+#include <iterator>
+#include <sprout/config.hpp>
+#include <sprout/iterator/transform_iterator.hpp>
+#include <sprout/ctype/functor.hpp>
+
+namespace sprout {
+	//
+	// make_to_lower_iterator
+	//
+	template<typename Iterator>
+	inline SPROUT_CONSTEXPR sprout::transform_iterator<sprout::ctypes::to_lower<typename std::iterator_traits<Iterator>::value_type>, Iterator>
+	make_to_lower_iterator(Iterator it) {
+		return sprout::transform_iterator<sprout::ctypes::to_lower<typename std::iterator_traits<Iterator>::value_type>, Iterator>(
+			it, sprout::ctypes::to_lower<typename std::iterator_traits<Iterator>::value_type>()
+			);
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_ITERATOR_TO_LOWER_ITERATOR_HPP

sprout/iterator/to_upper_iterator.hpp

@@ -0,0 +1,22 @@
+#ifndef SPROUT_ITERATOR_TO_UPPER_ITERATOR_HPP
+#define SPROUT_ITERATOR_TO_UPPER_ITERATOR_HPP
+
+#include <iterator>
+#include <sprout/config.hpp>
+#include <sprout/iterator/transform_iterator.hpp>
+#include <sprout/ctype/functor.hpp>
+
+namespace sprout {
+	//
+	// make_to_upper_iterator
+	//
+	template<typename Iterator>
+	inline SPROUT_CONSTEXPR sprout::transform_iterator<sprout::ctypes::to_upper<typename std::iterator_traits<Iterator>::value_type>, Iterator>
+	make_to_upper_iterator(Iterator it) {
+		return sprout::transform_iterator<sprout::ctypes::to_upper<typename std::iterator_traits<Iterator>::value_type>, Iterator>(
+			it, sprout::ctypes::to_upper<typename std::iterator_traits<Iterator>::value_type>()
+			);
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_ITERATOR_TO_UPPER_ITERATOR_HPP

sprout/range/adaptor.hpp

@@ -5,6 +5,7 @@
 #include <sprout/range/adaptor/modifying.hpp>
 #include <sprout/range/adaptor/reduction.hpp>
 #include <sprout/range/adaptor/various.hpp>
+#include <sprout/range/adaptor/string.hpp>
 #include <sprout/range/adaptor/wave.hpp>
 
 #endif	// #ifndef SPROUT_RANGE_ADAPTOR_HPP

sprout/range/adaptor/string.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_RANGE_ADAPTOR_STRING_HPP
+#define SPROUT_RANGE_ADAPTOR_STRING_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/range/adaptor/to_lower.hpp>
+#include <sprout/range/adaptor/to_upper.hpp>
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_STRING_HPP

sprout/range/adaptor/to_lower.hpp

@@ -0,0 +1,89 @@
+#ifndef SPROUT_RANGE_ADAPTOR_TO_LOWER_HPP
+#define SPROUT_RANGE_ADAPTOR_TO_LOWER_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/iterator/transform_iterator.hpp>
+#include <sprout/iterator/to_lower_iterator.hpp>
+#include <sprout/range/adaptor/detail/adapted_range_default.hpp>
+#include <sprout/type_traits/lvalue_reference.hpp>
+#include <sprout/utility/forward.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// to_lower_range
+		//
+		template<typename Range>
+		class to_lower_range
+			: public sprout::adaptors::detail::adapted_range_default<
+				Range,
+				sprout::transform_iterator<
+					sprout::ctypes::to_lower<typename sprout::container_traits<Range>::value_type>,
+					typename sprout::container_traits<Range>::iterator
+				>
+			>
+		{
+		public:
+			typedef sprout::adaptors::detail::adapted_range_default<
+				Range,
+				sprout::transform_iterator<
+					sprout::ctypes::to_lower<typename sprout::container_traits<Range>::value_type>,
+					typename sprout::container_traits<Range>::iterator
+				>
+			> base_type;
+			typedef typename base_type::range_type range_type;
+			typedef typename base_type::iterator iterator;
+			typedef typename base_type::value_type value_type;
+		public:
+			to_lower_range() = default;
+			to_lower_range(to_lower_range const&) = default;
+			explicit SPROUT_CONSTEXPR to_lower_range(range_type& range)
+				: base_type(
+					iterator(sprout::begin(range), typename iterator::functor_type()),
+					iterator(sprout::end(range), typename iterator::functor_type())
+					)
+			{}
+		};
+
+		//
+		// to_lower_forwarder
+		//
+		class to_lower_forwarder {};
+
+		//
+		// to_lower
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::to_lower_forwarder to_lower = {};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range>
+		inline SPROUT_CONSTEXPR sprout::adaptors::to_lower_range<
+			typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+		>
+		operator|(Range&& lhs, to_lower_forwarder) {
+			return sprout::adaptors::to_lower_range<
+				typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+			>(
+				sprout::lvalue_forward<Range>(lhs)
+				);
+		}
+	}	// namespace adaptors
+
+	//
+	// container_construct_traits
+	//
+	template<typename Range>
+	struct container_construct_traits<sprout::adaptors::to_lower_range<Range> >
+		: public sprout::container_construct_traits<typename sprout::adaptors::to_lower_range<Range>::base_type>
+	{};
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_TO_LOWER_HPP

sprout/range/adaptor/to_upper.hpp

@@ -0,0 +1,89 @@
+#ifndef SPROUT_RANGE_ADAPTOR_TO_UPPER_HPP
+#define SPROUT_RANGE_ADAPTOR_TO_UPPER_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/iterator/transform_iterator.hpp>
+#include <sprout/iterator/to_upper_iterator.hpp>
+#include <sprout/range/adaptor/detail/adapted_range_default.hpp>
+#include <sprout/type_traits/lvalue_reference.hpp>
+#include <sprout/utility/forward.hpp>
+#include <sprout/utility/lvalue_forward.hpp>
+
+namespace sprout {
+	namespace adaptors {
+		//
+		// to_upper_range
+		//
+		template<typename Range>
+		class to_upper_range
+			: public sprout::adaptors::detail::adapted_range_default<
+				Range,
+				sprout::transform_iterator<
+					sprout::ctypes::to_upper<typename sprout::container_traits<Range>::value_type>,
+					typename sprout::container_traits<Range>::iterator
+				>
+			>
+		{
+		public:
+			typedef sprout::adaptors::detail::adapted_range_default<
+				Range,
+				sprout::transform_iterator<
+					sprout::ctypes::to_upper<typename sprout::container_traits<Range>::value_type>,
+					typename sprout::container_traits<Range>::iterator
+				>
+			> base_type;
+			typedef typename base_type::range_type range_type;
+			typedef typename base_type::iterator iterator;
+			typedef typename base_type::value_type value_type;
+		public:
+			to_upper_range() = default;
+			to_upper_range(to_upper_range const&) = default;
+			explicit SPROUT_CONSTEXPR to_upper_range(range_type& range)
+				: base_type(
+					iterator(sprout::begin(range), typename iterator::functor_type()),
+					iterator(sprout::end(range), typename iterator::functor_type())
+					)
+			{}
+		};
+
+		//
+		// to_upper_forwarder
+		//
+		class to_upper_forwarder {};
+
+		//
+		// to_upper
+		//
+		namespace {
+			SPROUT_STATIC_CONSTEXPR sprout::adaptors::to_upper_forwarder to_upper = {};
+		}	// anonymous-namespace
+
+		//
+		// operator|
+		//
+		template<typename Range>
+		inline SPROUT_CONSTEXPR sprout::adaptors::to_upper_range<
+			typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+		>
+		operator|(Range&& lhs, to_upper_forwarder) {
+			return sprout::adaptors::to_upper_range<
+				typename std::remove_reference<typename sprout::lvalue_reference<Range>::type>::type
+			>(
+				sprout::lvalue_forward<Range>(lhs)
+				);
+		}
+	}	// namespace adaptors
+
+	//
+	// container_construct_traits
+	//
+	template<typename Range>
+	struct container_construct_traits<sprout::adaptors::to_upper_range<Range> >
+		: public sprout::container_construct_traits<typename sprout::adaptors::to_upper_range<Range>::base_type>
+	{};
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ADAPTOR_TO_UPPER_HPP

sprout/range/algorithm/fit/copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/copy.hpp>

sprout/range/algorithm/fit/copy_backward.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_COPY_BACKWARD_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/copy_backward.hpp>

sprout/range/algorithm/fit/copy_if.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_COPY_IF_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/copy_if.hpp>

sprout/range/algorithm/fit/copy_until.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_COPY_UNTIL_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/copy_until.hpp>

sprout/range/algorithm/fit/copy_while.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_COPY_WHILE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/copy_while.hpp>

sprout/range/algorithm/fit/merge.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_MERGE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/merge.hpp>

sprout/range/algorithm/fit/partition_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_PARTITION_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/partition_copy.hpp>

sprout/range/algorithm/fit/remove_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_REMOVE_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/remove_copy.hpp>

sprout/range/algorithm/fit/remove_copy_if.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_REMOVE_COPY_IF_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/remove_copy_if.hpp>

sprout/range/algorithm/fit/replace_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_REPLACE_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/replace_copy.hpp>

sprout/range/algorithm/fit/replace_copy_if.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_REPLACE_COPY_IF_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/replace_copy_if.hpp>

sprout/range/algorithm/fit/reverse_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_REVERSE_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/reverse_copy.hpp>

sprout/range/algorithm/fit/set_difference.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_SET_DIFFERENCE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/set_difference.hpp>

sprout/range/algorithm/fit/set_intersection.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_SET_INTERSECTION_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/set_intersection.hpp>

sprout/range/algorithm/fit/set_symmetric_difference.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_SET_SYMMETRIC_DIFFERENCE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/set_symmetric_difference.hpp>

sprout/range/algorithm/fit/set_union.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_SET_UNION_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/set_union.hpp>

sprout/range/algorithm/fit/stable_partition_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_STABLE_PARTITION_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/stable_partition_copy.hpp>

sprout/range/algorithm/fit/transform.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_TRANSFORM_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/transform.hpp>

sprout/range/algorithm/fit/unique_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIT_UNIQUE_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fit/result_of.hpp>
 #include <sprout/algorithm/fit/unique_copy.hpp>

sprout/range/algorithm/fixed/copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/copy.hpp>

sprout/range/algorithm/fixed/copy_backward.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_COPY_BACKWARD_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/copy_backward.hpp>

sprout/range/algorithm/fixed/copy_if.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_COPY_IF_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/copy_if.hpp>

sprout/range/algorithm/fixed/copy_until.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_COPY_UNTIL_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/copy_until.hpp>

sprout/range/algorithm/fixed/copy_while.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_COPY_WHILE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/copy_while.hpp>

sprout/range/algorithm/fixed/merge.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_MERGE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/merge.hpp>

sprout/range/algorithm/fixed/partition_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_PARTITION_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/partition_copy.hpp>

sprout/range/algorithm/fixed/remove_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_REMOVE_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/remove_copy.hpp>

sprout/range/algorithm/fixed/remove_copy_if.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_REMOVE_COPY_IF_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/remove_copy_if.hpp>

sprout/range/algorithm/fixed/replace_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_REPLACE_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/replace_copy.hpp>

sprout/range/algorithm/fixed/replace_copy_if.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_REPLACE_COPY_IF_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/replace_copy_if.hpp>

sprout/range/algorithm/fixed/reverse_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_REVERSE_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/reverse_copy.hpp>

sprout/range/algorithm/fixed/set_difference.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_SET_DIFFERENCE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/set_difference.hpp>

sprout/range/algorithm/fixed/set_intersection.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_SET_INTERSECTION_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/set_intersection.hpp>

sprout/range/algorithm/fixed/set_symmetric_difference.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_SET_SYMMETRIC_DIFFERENCE_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/set_symmetric_difference.hpp>

sprout/range/algorithm/fixed/set_union.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_SET_UNION_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/set_union.hpp>

sprout/range/algorithm/fixed/stable_partition_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_STABLE_PARTITION_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/stable_partition_copy.hpp>

sprout/range/algorithm/fixed/transform.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_TRANSFORM_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/transform.hpp>

sprout/range/algorithm/fixed/unique_copy.hpp

@@ -2,7 +2,6 @@
 #define SPROUT_RANGE_ALGORITHM_FIXED_UNIQUE_COPY_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/unique_copy.hpp>

sprout/range/algorithm/string.hpp

@@ -0,0 +1,7 @@
+#ifndef SPROUT_RANGE_ALGORITHM_STRING_HPP
+#define SPROUT_RANGE_ALGORITHM_STRING_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/range/algorithm/string/case_conv.hpp>
+
+#endif	// #ifndef SPROUT_RANGE_ALGORITHM_STRING_HPP

sprout/range/algorithm/string/case_conv.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_RANGE_ALGORITHM_STRING_CASE_CONV_HPP
+#define SPROUT_RANGE_ALGORITHM_STRING_CASE_CONV_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/range/algorithm/string/fixed/case_conv.hpp>
+#include <sprout/range/algorithm/string/fit/case_conv.hpp>
+
+#endif	// #ifndef SPROUT_RANGE_ALGORITHM_STRING_CASE_CONV_HPP

sprout/range/algorithm/string/fit/case_conv.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_RANGE_ALGORITHM_STRING_FIT_CASE_CONV_HPP
+#define SPROUT_RANGE_ALGORITHM_STRING_FIT_CASE_CONV_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/range/algorithm/string/fit/to_lower_copy.hpp>
+#include <sprout/range/algorithm/string/fit/to_upper_copy.hpp>
+
+#endif	// #ifndef SPROUT_RANGE_ALGORITHM_STRING_FIT_CASE_CONV_HPP

sprout/range/algorithm/string/fit/to_lower_copy.hpp

@@ -0,0 +1,32 @@
+#ifndef SPROUT_RANGE_ALGORITHM_STRING_FIT_TO_LOWER_COPY_HPP
+#define SPROUT_RANGE_ALGORITHM_STRING_FIT_TO_LOWER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/algorithm/fit/result_of.hpp>
+#include <sprout/algorithm/string/fit/to_lower_copy.hpp>
+
+namespace sprout {
+	namespace range {
+		namespace algorithm {
+			namespace fit {
+				//
+				// to_lower_copy
+				//
+				template<typename InputRange, typename Result>
+				inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
+				to_lower_copy(InputRange const& rng, Result const& result) {
+					return sprout::fit::to_lower_copy(sprout::begin(rng), sprout::end(rng), result);
+				}
+			}	// namespace fit
+
+			using sprout::range::algorithm::fit::to_lower_copy;
+		}	// namespace algorithm
+
+		namespace fit {
+			using sprout::range::algorithm::fit::to_lower_copy;
+		}	// namespace fit
+	}	// namespace range
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ALGORITHM_STRING_FIT_TO_LOWER_COPY_HPP

sprout/range/algorithm/string/fit/to_upper_copy.hpp

@@ -0,0 +1,32 @@
+#ifndef SPROUT_RANGE_ALGORITHM_STRING_FIT_TO_UPPER_COPY_HPP
+#define SPROUT_RANGE_ALGORITHM_STRING_FIT_TO_UPPER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/algorithm/fit/result_of.hpp>
+#include <sprout/algorithm/string/fit/to_upper_copy.hpp>
+
+namespace sprout {
+	namespace range {
+		namespace algorithm {
+			namespace fit {
+				//
+				// to_upper_copy
+				//
+				template<typename InputRange, typename Result>
+				inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
+				to_upper_copy(InputRange const& rng, Result const& result) {
+					return sprout::fit::to_upper_copy(sprout::begin(rng), sprout::end(rng), result);
+				}
+			}	// namespace fit
+
+			using sprout::range::algorithm::fit::to_upper_copy;
+		}	// namespace algorithm
+
+		namespace fit {
+			using sprout::range::algorithm::fit::to_upper_copy;
+		}	// namespace fit
+	}	// namespace range
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ALGORITHM_STRING_FIT_TO_UPPER_COPY_HPP

sprout/range/algorithm/string/fixed/case_conv.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_RANGE_ALGORITHM_STRING_FIXED_CASE_CONV_HPP
+#define SPROUT_RANGE_ALGORITHM_STRING_FIXED_CASE_CONV_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/range/algorithm/string/fixed/to_lower_copy.hpp>
+#include <sprout/range/algorithm/string/fixed/to_upper_copy.hpp>
+
+#endif	// #ifndef SPROUT_RANGE_ALGORITHM_STRING_FIXED_CASE_CONV_HPP

sprout/range/algorithm/string/fixed/to_lower_copy.hpp

@@ -0,0 +1,41 @@
+#ifndef SPROUT_RANGE_ALGORITHM_STRING_FIXED_TO_LOWER_COPY_HPP
+#define SPROUT_RANGE_ALGORITHM_STRING_FIXED_TO_LOWER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/algorithm/string/fixed/to_lower_copy.hpp>
+
+namespace sprout {
+	namespace range {
+		namespace algorithm {
+			namespace fixed {
+				//
+				// to_lower_copy
+				//
+				template<typename InputRange, typename Result>
+				inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+				to_lower_copy(InputRange const& rng, Result const& result) {
+					return sprout::algorithm::fixed::to_lower_copy(sprout::begin(rng), sprout::end(rng), result);
+				}
+
+				template<typename Result, typename InputRange>
+				inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+				to_lower_copy(InputRange const& rng) {
+					return sprout::algorithm::fixed::to_lower_copy<Result>(sprout::begin(rng), sprout::end(rng));
+				}
+			}	// namespace fixed
+
+			using sprout::range::algorithm::fixed::to_lower_copy;
+		}	// namespace algorithm
+
+		namespace fixed {
+			using sprout::range::algorithm::fixed::to_lower_copy;
+		}	// namespace fixed
+
+		using sprout::range::algorithm::fixed::to_lower_copy;
+	}	// namespace range
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ALGORITHM_STRING_FIXED_TO_LOWER_COPY_HPP

sprout/range/algorithm/string/fixed/to_upper_copy.hpp

@@ -0,0 +1,41 @@
+#ifndef SPROUT_RANGE_ALGORITHM_STRING_FIXED_TO_UPPER_COPY_HPP
+#define SPROUT_RANGE_ALGORITHM_STRING_FIXED_TO_UPPER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/container/traits.hpp>
+#include <sprout/container/functions.hpp>
+#include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/algorithm/string/fixed/to_upper_copy.hpp>
+
+namespace sprout {
+	namespace range {
+		namespace algorithm {
+			namespace fixed {
+				//
+				// to_upper_copy
+				//
+				template<typename InputRange, typename Result>
+				inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+				to_upper_copy(InputRange const& rng, Result const& result) {
+					return sprout::algorithm::fixed::to_upper_copy(sprout::begin(rng), sprout::end(rng), result);
+				}
+
+				template<typename Result, typename InputRange>
+				inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+				to_upper_copy(InputRange const& rng) {
+					return sprout::algorithm::fixed::to_upper_copy<Result>(sprout::begin(rng), sprout::end(rng));
+				}
+			}	// namespace fixed
+
+			using sprout::range::algorithm::fixed::to_upper_copy;
+		}	// namespace algorithm
+
+		namespace fixed {
+			using sprout::range::algorithm::fixed::to_upper_copy;
+		}	// namespace fixed
+
+		using sprout::range::algorithm::fixed::to_upper_copy;
+	}	// namespace range
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_RANGE_ALGORITHM_STRING_FIXED_TO_UPPER_COPY_HPP

sprout/range/algorithm/string/to_lower_copy.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_RANGE_ALGORITHM_STRING_TO_LOWER_COPY_HPP
+#define SPROUT_RANGE_ALGORITHM_STRING_TO_LOWER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/range/algorithm/string/fixed/to_lower_copy.hpp>
+#include <sprout/range/algorithm/string/fit/to_lower_copy.hpp>
+
+#endif	// #ifndef SPROUT_RANGE_ALGORITHM_STRING_TO_LOWER_COPY_HPP

sprout/range/algorithm/string/to_upper_copy.hpp

@@ -0,0 +1,8 @@
+#ifndef SPROUT_RANGE_ALGORITHM_STRING_TO_UPPER_COPY_HPP
+#define SPROUT_RANGE_ALGORITHM_STRING_TO_UPPER_COPY_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/range/algorithm/string/fixed/to_upper_copy.hpp>
+#include <sprout/range/algorithm/string/fit/to_upper_copy.hpp>
+
+#endif	// #ifndef SPROUT_RANGE_ALGORITHM_STRING_TO_UPPER_COPY_HPP