diff --git a/sprout/functional/hash/hash.hpp b/sprout/functional/hash/hash.hpp
index 804ac9de..8fbc194d 100644
--- a/sprout/functional/hash/hash.hpp
+++ b/sprout/functional/hash/hash.hpp
@@ -26,9 +26,9 @@ namespace sprout {
 	inline SPROUT_CONSTEXPR std::size_t hash_value(unsigned long v);
 	inline SPROUT_CONSTEXPR std::size_t hash_value(long long v);
 	inline SPROUT_CONSTEXPR std::size_t hash_value(unsigned long long v);
-	//SPROUT_CONSTEXPR std::size_t inline hash_value(float v);
-	//SPROUT_CONSTEXPR std::size_t inline hash_value(double v);
-	//SPROUT_CONSTEXPR std::size_t inline hash_value(long double v);
+	//inline SPROUT_CONSTEXPR std::size_t hash_value(float v);
+	//inline SPROUT_CONSTEXPR std::size_t hash_value(double v);
+	//inline SPROUT_CONSTEXPR std::size_t hash_value(long double v);
 	template<typename T>
 	SPROUT_CONSTEXPR std::size_t hash_value(T*);
 	template<typename T, std::size_t N>
diff --git a/sprout/functional/hash/string.hpp b/sprout/functional/hash/string.hpp
index eff4f892..9557e27e 100644
--- a/sprout/functional/hash/string.hpp
+++ b/sprout/functional/hash/string.hpp
@@ -1,17 +1,9 @@
 #ifndef SPROUT_FUNCTIONAL_HASH_STRING_HPP
 #define SPROUT_FUNCTIONAL_HASH_STRING_HPP
 
-#include <cstddef>
 #include <sprout/config.hpp>
 #include <sprout/functional/hash/hash.hpp>
-#include <sprout/string.hpp>
-
-namespace sprout {
-	template<typename T, std::size_t N, typename Traits>
-	SPROUT_CONSTEXPR std::size_t hash_value(sprout::basic_string<T, N, Traits> const& v) {
-		return sprout::hash_range(v.begin(), v.end());
-	}
-}	// namespace sprout
+#include <sprout/string/hash.hpp>
 
 #endif	// #ifndef SPROUT_FUNCTIONAL_HASH_STRING_HPP
 
diff --git a/sprout/integer/integer_digits.hpp b/sprout/integer/integer_digits.hpp
index e23b8349..3e711da4 100644
--- a/sprout/integer/integer_digits.hpp
+++ b/sprout/integer/integer_digits.hpp
@@ -8,9 +8,6 @@
 
 namespace sprout {
 	namespace detail {
-		//
-		// integer_digits_impl
-		//
 		template<typename IntType, long N, long D>
 		struct integer_digits_impl
 			: public std::integral_constant<
@@ -24,7 +21,7 @@ namespace sprout {
 	//
 	// integer_digits
 	//
-	template<typename IntType, std::size_t Base>
+	template<typename IntType, std::size_t Base = 10>
 	struct integer_digits;
 
 	template<typename IntType>
diff --git a/sprout/string.hpp b/sprout/string.hpp
index 87958d13..31ce6ae1 100644
--- a/sprout/string.hpp
+++ b/sprout/string.hpp
@@ -1,1071 +1,18 @@
 #ifndef SPROUT_STRING_HPP
 #define SPROUT_STRING_HPP
 
-#include <cstddef>
-#include <ios>
-#include <algorithm>
-#include <utility>
-#include <string>
-#include <stdexcept>
-#include <type_traits>
 #include <sprout/config.hpp>
-#include <sprout/array.hpp>
-#include <sprout/index_tuple.hpp>
-#include <sprout/container/traits.hpp>
-#include <sprout/operation/fixed/push_back.hpp>
-#include <sprout/operation/fixed/push_front.hpp>
-#include <sprout/operation/fixed/append_back.hpp>
-#include <sprout/operation/fixed/append_front.hpp>
-#include <sprout/iterator.hpp>
-#include <sprout/utility/forward.hpp>
-#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
-#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
-#	include <algorithm>
-#	include <sprout/iterator/index_iterator.hpp>
-#endif
-
-namespace sprout {
-	//
-	// char_traits
-	//
-	template<typename Char>
-	class char_traits {
-	private:
-		typedef std::char_traits<Char> impl_type;
-	public:
-		typedef typename impl_type::char_type char_type;
-		typedef typename impl_type::int_type int_type;
-		typedef typename impl_type::off_type off_type;
-		typedef typename impl_type::pos_type pos_type;
-		typedef typename impl_type::state_type state_type;
-	public:
-		static void assign(char_type& c1, char_type const& c2) SPROUT_NOEXCEPT {
-			impl_type::assign(c1, c2);
-		}
-		static SPROUT_CONSTEXPR bool eq(char_type c1, char_type c2) SPROUT_NOEXCEPT {
-			return impl_type::eq(c1, c2);
-		}
-		static SPROUT_CONSTEXPR bool lt(char_type c1, char_type c2) SPROUT_NOEXCEPT {
-			return impl_type::lt(c1, c2);
-		}
-		static SPROUT_CONSTEXPR int compare(char_type const* s1, char_type const* s2, std::size_t n) {
-			return !n ? 0
-				: lt(*s1, *s2) ? -1
-				: lt(*s2, *s1) ? 1
-				: compare(s1 + 1, s2 + 1, n - 1)
-				;
-		}
-		static SPROUT_CONSTEXPR std::size_t length(char_type const* s) {
-			return !*s ? 0
-				: 1 + length(s + 1)
-				;
-		}
-		static SPROUT_CONSTEXPR char_type const* find(char_type const* s, std::size_t n, char_type const& a) {
-			return !n ? nullptr
-				: eq(*s, a) ? s
-				: find(s + 1, n - 1, a)
-				;
-		}
-		static char_type* move(char_type* s1, char_type const* s2, std::size_t n) {
-			return impl_type::move(s1, s2, n);
-		}
-		static char_type* copy(char_type* s1, char_type const* s2, std::size_t n) {
-			return impl_type::copy(s1, s2, n);
-		}
-		static char_type* assign(char_type* s, std::size_t n, char_type a) {
-			return impl_type::assign(s, n, a);
-		}
-		static SPROUT_CONSTEXPR int_type not_eof(int_type c) SPROUT_NOEXCEPT {
-			return impl_type::not_eof(c);
-		}
-		static SPROUT_CONSTEXPR char_type to_char_type(int_type c) SPROUT_NOEXCEPT {
-			return impl_type::to_char_type(c);
-		}
-		static SPROUT_CONSTEXPR int_type to_int_type(char_type c) SPROUT_NOEXCEPT {
-			return impl_type::to_int_type(c);
-		}
-		static SPROUT_CONSTEXPR bool eq_int_type(int_type c1, int_type c2) SPROUT_NOEXCEPT {
-			return impl_type::eq_int_type(c1, c2);
-		}
-		static SPROUT_CONSTEXPR int_type eof() SPROUT_NOEXCEPT {
-			return impl_type::eof();
-		}
-#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
-		template<typename ConstIterator>
-		static SPROUT_CONSTEXPR int compare(char_type const* s1, ConstIterator s2, std::size_t n) {
-			return !n ? 0
-				: lt(*s1, *s2) ? -1
-				: lt(*s2, *s1) ? 1
-				: compare(s1 + 1, s2 + 1, n - 1)
-				;
-		}
-		template<typename ConstIterator>
-		static SPROUT_CONSTEXPR int compare(ConstIterator s1, char_type const* s2, std::size_t n) {
-			return !n ? 0
-				: lt(*s1, *s2) ? -1
-				: lt(*s2, *s1) ? 1
-				: compare(s1 + 1, s2 + 1, n - 1)
-				;
-		}
-		template<typename ConstIterator1, typename ConstIterator2>
-		static SPROUT_CONSTEXPR int compare(ConstIterator1 s1, ConstIterator2 s2, std::size_t n) {
-			return !n ? 0
-				: lt(*s1, *s2) ? -1
-				: lt(*s2, *s1) ? 1
-				: compare(s1 + 1, s2 + 1, n - 1)
-				;
-		}
-		template<typename ConstIterator>
-		static SPROUT_CONSTEXPR std::size_t length(ConstIterator s) {
-			return !*s ? 0
-				: 1 + length(s + 1)
-				;
-		}
-		template<typename ConstIterator>
-		static SPROUT_CONSTEXPR ConstIterator find(ConstIterator s, std::size_t n, char_type const& a) {
-			return !n ? nullptr
-				: eq(*s, a) ? s
-				: find(s + 1, n - 1, a)
-				;
-		}
-		template<typename Iterator, typename ConstIterator>
-		static Iterator move(Iterator s1, ConstIterator s2, std::size_t n) {
-			std::copy_backward(s2, s2 + n, s1);
-			return s1;
-		}
-		template<typename Iterator, typename ConstIterator>
-		static Iterator copy(Iterator s1, ConstIterator s2, std::size_t n) {
-			std::copy(s2, s2 + n, s1);
-			return s1;
-		}
-		template<typename Iterator>
-		static Iterator assign(Iterator s, std::size_t n, char_type a) {
-			std::fill(s, s + n, a);
-			return s;
-		}
-#endif
-	};
-
-	//
-	// basic_string
-	//
-	template<typename T, std::size_t N, typename Traits = sprout::char_traits<T> >
-	class basic_string {
-	public:
-		typedef T value_type;
-#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
-		typedef sprout::index_iterator<basic_string&> iterator;
-		typedef sprout::index_iterator<basic_string const&> const_iterator;
-#else
-		typedef T* iterator;
-		typedef T const* const_iterator;
-#endif
-		typedef T& reference;
-		typedef T const& const_reference;
-		typedef std::size_t size_type;
-		typedef std::ptrdiff_t difference_type;
-		typedef T* pointer;
-		typedef T const* const_pointer;
-		typedef sprout::reverse_iterator<iterator> reverse_iterator;
-		typedef sprout::reverse_iterator<const_iterator> const_reverse_iterator;
-		typedef Traits traits_type;
-	public:
-		SPROUT_STATIC_CONSTEXPR size_type npos = -1;
-		SPROUT_STATIC_CONSTEXPR size_type static_size = N;
-	private:
-		static SPROUT_CONSTEXPR int compare_impl_2(int compared, size_type n1, size_type n2) {
-			return compared != 0 ? compared
-				: n1 < n2 ? -1
-				: n2 < n1 ? 1
-				: 0
-				;
-		}
-		static SPROUT_CONSTEXPR int compare_impl_1(value_type const* dest, size_type pos1, size_type n1, value_type const* s, size_type n2) {
-			return compare_impl_2(
-				traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
-				n1,
-				n2
-				);
-		}
-		template<sprout::index_t... Indexes>
-		static SPROUT_CONSTEXPR basic_string<T, N, Traits> from_c_str_impl(
-			value_type const* s,
-			size_type n,
-			sprout::index_tuple<Indexes...>
-			)
-		{
-			return sprout::basic_string<T, N, Traits>{{(Indexes < n ? s[Indexes] : T())...}, n};
-		}
-#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
-		template<typename ConstIterator>
-		static SPROUT_CONSTEXPR typename std::enable_if<
-			sprout::is_index_iterator<ConstIterator>::value,
-			int
-		>::type compare_impl_1(value_type const* dest, size_type pos1, size_type n1, ConstIterator s, size_type n2) {
-			return compare_impl_2(
-				traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
-				n1,
-				n2
-				);
-		}
-		static SPROUT_CONSTEXPR int compare_impl_1(const_iterator dest, size_type pos1, size_type n1, value_type const* s, size_type n2) {
-			return compare_impl_2(
-				traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
-				n1,
-				n2
-				);
-		}
-		template<typename ConstIterator>
-		static SPROUT_CONSTEXPR typename std::enable_if<
-			sprout::is_index_iterator<ConstIterator>::value,
-			int
-		>::type compare_impl_1(const_iterator dest, size_type pos1, size_type n1, ConstIterator s, size_type n2) {
-			return compare_impl_2(
-				traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
-				n1,
-				n2
-				);
-		}
-#endif
-		template<std::size_t M, sprout::index_t... Indexes>
-		static SPROUT_CONSTEXPR basic_string<T, sizeof...(Indexes), Traits> implicit_conversion_impl(
-			T const(& elems)[M],
-			size_type len,
-			sprout::index_tuple<Indexes...>
-			)
-		{
-			return sprout::basic_string<T, sizeof...(Indexes), Traits>{{(Indexes < M - 1 ? elems[Indexes] : T())...}, len};
-		}
-	public:
-		static SPROUT_CONSTEXPR basic_string<T, N, Traits> from_c_str(value_type const* s, size_type n) {
-			return !(N < n)
-				? from_c_str_impl(s, n, typename sprout::index_range<0, N>::type())
-				: throw std::out_of_range("basic_string<>: index out of range")
-				;
-		}
-		static SPROUT_CONSTEXPR basic_string<T, N, Traits> from_c_str(value_type const* s) {
-			return from_c_str(s, traits_type::length(s));
-		}
-	public:
-		value_type elems[static_size + 1];
-		size_type len;
-	public:
-		// construct/copy/destroy:
-		template<std::size_t N2>
-		basic_string<T, N, Traits>& operator=(basic_string<T, N2, Traits> const& rhs) {
-			return assign(rhs);
-		}
-		basic_string<T, N, Traits>& operator=(value_type const* rhs) {
-			return assign(rhs);
-		}
-		basic_string<T, N, Traits>& operator=(value_type rhs) {
-			return assign(1, rhs);
-		}
-		// iterators:
-#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
-		iterator begin() SPROUT_NOEXCEPT {
-			return iterator(*this, 0);
-		}
-		SPROUT_CONSTEXPR const_iterator begin() const SPROUT_NOEXCEPT {
-			return const_iterator(*this, 0);
-		}
-		iterator end() SPROUT_NOEXCEPT {
-			return iterator(*this, size());
-		}
-		SPROUT_CONSTEXPR const_iterator end() const SPROUT_NOEXCEPT {
-			return const_iterator(*this, size());
-		}
-#else
-		iterator begin() SPROUT_NOEXCEPT {
-			return &elems[0];
-		}
-		SPROUT_CONSTEXPR const_iterator begin() const SPROUT_NOEXCEPT {
-			return &elems[0];
-		}
-		iterator end() SPROUT_NOEXCEPT {
-			return &elems[0] + size();
-		}
-		SPROUT_CONSTEXPR const_iterator end() const SPROUT_NOEXCEPT {
-			return &elems[0] + size();
-		}
-#endif
-		reverse_iterator rbegin() SPROUT_NOEXCEPT {
-			return const_reverse_iterator(end());
-		}
-		SPROUT_CONSTEXPR const_reverse_iterator rbegin() const SPROUT_NOEXCEPT {
-			return const_reverse_iterator(end());
-		}
-		reverse_iterator rend() SPROUT_NOEXCEPT {
-			return const_reverse_iterator(begin());
-		}
-		SPROUT_CONSTEXPR const_reverse_iterator rend() const SPROUT_NOEXCEPT {
-			return const_reverse_iterator(begin());
-		}
-#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
-		SPROUT_CONSTEXPR const_iterator cbegin() const SPROUT_NOEXCEPT {
-			return const_iterator(*this, 0);
-		}
-		SPROUT_CONSTEXPR const_iterator cend() const SPROUT_NOEXCEPT {
-			return const_iterator(*this, size());
-		}
-#else
-		SPROUT_CONSTEXPR const_iterator cbegin() const SPROUT_NOEXCEPT {
-			return &elems[0];
-		}
-		SPROUT_CONSTEXPR const_iterator cend() const SPROUT_NOEXCEPT {
-			return &elems[0] + size();
-		}
-#endif
-		SPROUT_CONSTEXPR const_reverse_iterator crbegin() const SPROUT_NOEXCEPT {
-			return const_reverse_iterator(end());
-		}
-		SPROUT_CONSTEXPR const_reverse_iterator crend() const SPROUT_NOEXCEPT {
-			return const_reverse_iterator(begin());
-		}
-		// capacity:
-		SPROUT_CONSTEXPR size_type size() const SPROUT_NOEXCEPT {
-			return len;
-		}
-		SPROUT_CONSTEXPR size_type length() const SPROUT_NOEXCEPT {
-			return size();
-		}
-		SPROUT_CONSTEXPR size_type max_size() const SPROUT_NOEXCEPT {
-			return static_size;
-		}
-		void resize(size_type n, value_type c) {
-			maxcheck(n);
-			if (n > size()) {
-				traits_type::assign(end(), n - size(), c);
-			}
-			traits_type::assign(begin() + n, max_size() - n, value_type());
-			len = n;
-		}
-		void resize(size_type n) {
-			resize(n, value_type());
-		}
-		void clear() {
-			traits_type::assign(begin(), max_size(), value_type());
-			len = 0;
-		}
-		SPROUT_CONSTEXPR bool empty() const SPROUT_NOEXCEPT {
-			return size() == 0;
-		}
-		// element access:
-		reference operator[](size_type i) {
-			return elems[i];
-		}
-		SPROUT_CONSTEXPR const_reference operator[](size_type i) const {
-			return elems[i];
-		}
-		reference at(size_type i) {
-			return i < size()
-				? elems[i]
-				: (throw std::out_of_range("basic_string<>: index out of range"), elems[i])
-				;
-		}
-		SPROUT_CONSTEXPR const_reference at(size_type i) const {
-			return i < size()
-				? elems[i]
-				: (throw std::out_of_range("basic_string<>: index out of range"), elems[i])
-				;
-		}
-		reference front() {
-			return elems[0];
-		}
-		SPROUT_CONSTEXPR const_reference front() const {
-			return elems[0];
-		}
-		reference back() {
-			return elems[size() - 1];
-		}
-		SPROUT_CONSTEXPR const_reference back() const {
-			return elems[size() - 1];
-		}
-		// modifiers:
-		template<std::size_t N2>
-		basic_string<T, N, Traits>& assign(basic_string<T, N2, Traits> const& str) {
-			return assign(str.begin(), str.size());
-		}
-		template<std::size_t N2>
-		basic_string<T, N, Traits>& assign(basic_string<T, N2, Traits> const& str, size_type pos, size_type n) {
-			if (str.size() < pos + n) {
-				throw std::out_of_range("basic_string<>: index out of range");
-			}
-			return assign(str.begin() + pos, n);
-		}
-		basic_string<T, N, Traits>& assign(value_type const* s, size_type n) {
-			maxcheck(n);
-			for (size_type i = 0; i < n; ++i) {
-				traits_type::assign(elems[i], s[i]);
-			}
-			for (size_type i = n; i < max_size(); ++i) {
-				traits_type::assign(elems[i], value_type());
-			}
-			len = n;
-			return *this;
-		}
-		basic_string<T, N, Traits>& assign(value_type const* s) {
-			return assign(s, traits_type::length(s));
-		}
-		basic_string<T, N, Traits>& assign(size_type n, value_type c) {
-			maxcheck(n);
-			traits_type::assign(begin(), n, c);
-			traits_type::assign(begin() + n, max_size() - n, value_type());
-			len = n;
-			return *this;
-		}
-		template<typename Iterator>
-		basic_string<T, N, Traits>& assign(Iterator first, Iterator last) {
-			size_type n = 0;
-			for (; n < max_size() || first != last; ++n, ++first) {
-				traits_type::assign(elems[n], *first);
-			}
-			for (size_type i = n; i < max_size(); ++i) {
-				traits_type::assign(elems[i], value_type());
-			}
-			len = n;
-			return *this;
-		}
-		void swap(basic_string<T, N, Traits>& other) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(std::swap(std::declval<T&>(), std::declval<T&>()))) {
-			std::swap_ranges(other.begin(), other.begin() + other.max_size(), begin());
-			{
-				using std::swap;
-				swap(len, other.len);
-			}
-		}
-		// string operations:
-		SPROUT_CONSTEXPR const_pointer c_str() const SPROUT_NOEXCEPT {
-			return &elems[0];
-		}
-		pointer data() SPROUT_NOEXCEPT {
-			return &elems[0];
-		}
-		SPROUT_CONSTEXPR const_pointer data() const SPROUT_NOEXCEPT {
-			return &elems[0];
-		}
-		SPROUT_CONSTEXPR basic_string<T, N, Traits> substr(size_type pos = 0, size_type n = npos) const {
-			return !(size() < pos)
-				? n == npos
-					? substr(pos, size() - pos)
-					: from_c_str(c_str() + pos, n)
-				: throw std::out_of_range("basic_string<>: index out of range")
-				;
-		}
-		template<std::size_t N2>
-		SPROUT_CONSTEXPR int compare(basic_string<T, N2, Traits> const& str) const {
-			return compare(0, size(), str.begin(), str.size());
-		}
-		SPROUT_CONSTEXPR int compare(value_type const* s) const {
-			return compare(0, size(), s, traits_type::length(s));
-		}
-		template<std::size_t N2>
-		SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, basic_string<T, N2, Traits> const& str) const {
-			return compare(pos1, n1, str, 0, npos);
-		}
-		SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, value_type const* s) const {
-			return compare(pos1, n1, s, traits_type::length(s));
-		}
-		template<std::size_t N2>
-		SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, basic_string<T, N2, Traits> const& str, size_type pos2, size_type n2) const {
-			return !(str.size() < pos2)
-				? compare(pos1, n1, str.begin() + pos2, NS_SSCRISK_CEL_OR_SPROUT::min(n2, str.size() - pos2))
-				: throw std::out_of_range("basic_string<>: index out of range")
-				;
-		}
-		SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, value_type const* s, size_type n2) const {
-			return !(size() < pos1)
-				? compare_impl_1(begin(), pos1, NS_SSCRISK_CEL_OR_SPROUT::min(n1, size() - pos1), s, n2)
-				: throw std::out_of_range("basic_string<>: index out of range")
-				;
-		}
-		// others:
-		template<std::size_t N2, typename Enable = typename std::enable_if<(N2 > N)>::type>
-		SPROUT_CONSTEXPR operator basic_string<T, N2, Traits>() const {
-			return implicit_conversion_impl(
-				elems,
-				len,
-				typename sprout::index_range<0, N2>::type()
-				);
-		}
-		pointer c_array() SPROUT_NOEXCEPT {
-			return &elems[0];
-		}
-		void rangecheck(size_type i) const {
-			if (i >= size()) {
-				throw std::out_of_range("basic_string<>: index out of range");
-			}
-		}
-		void maxcheck(size_type n) const {
-			if (n > max_size()) {
-				throw std::out_of_range("basic_string<>: index out of range");
-			}
-		}
-#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
-		template<typename ConstIterator>
-		typename std::enable_if<
-			sprout::is_index_iterator<ConstIterator>::value,
-			basic_string<T, N, Traits>&
-		>::type assign(ConstIterator s, size_type n) {
-			maxcheck(n);
-			for (size_type i = 0; i < n; ++i) {
-				traits_type::assign(elems[i], s[i]);
-			}
-			for (size_type i = n; i < max_size(); ++i) {
-				traits_type::assign(elems[i], value_type());
-			}
-			len = n;
-			return *this;
-		}
-		template<typename ConstIterator>
-		typename std::enable_if<
-			sprout::is_index_iterator<ConstIterator>::value,
-			basic_string<T, N, Traits>&
-		>::type assign(ConstIterator s) {
-			return assign(s, traits_type::length(s));
-		}
-		template<typename ConstIterator>
-		typename std::enable_if<
-			sprout::is_index_iterator<ConstIterator>::value,
-			basic_string<T, N, Traits>&
-		>::type operator=(ConstIterator rhs) {
-			return assign(rhs);
-		}
-		template<typename ConstIterator>
-		SPROUT_CONSTEXPR typename std::enable_if<
-			sprout::is_index_iterator<ConstIterator>::value,
-			int
-		>::type compare(ConstIterator s) const {
-			return compare(0, size(), s, traits_type::length(s));
-		}
-		template<typename ConstIterator>
-		SPROUT_CONSTEXPR typename std::enable_if<
-			sprout::is_index_iterator<ConstIterator>::value,
-			int
-		>::type compare(size_type pos1, size_type n1, ConstIterator s) const {
-			return compare(pos1, n1, s, traits_type::length(s));
-		}
-		template<typename ConstIterator>
-		SPROUT_CONSTEXPR typename std::enable_if<
-			sprout::is_index_iterator<ConstIterator>::value,
-			int
-		>::type compare(size_type pos1, size_type n1, ConstIterator s, size_type n2) const {
-			return !(size() < pos1)
-				? compare_impl_1(begin(), pos1, NS_SSCRISK_CEL_OR_SPROUT::min(n1, size() - pos1), s, n2)
-				: throw std::out_of_range("basic_string<>: index out of range")
-				;
-		}
-#endif
-	};
-	template<typename T, std::size_t N, typename Traits>
-	SPROUT_CONSTEXPR typename sprout::basic_string<T, N, Traits>::size_type sprout::basic_string<T, N, Traits>::npos;
-	template<typename T, std::size_t N, typename Traits>
-	SPROUT_CONSTEXPR typename sprout::basic_string<T, N, Traits>::size_type sprout::basic_string<T, N, Traits>::static_size;
-
-	//
-	// operator==
-	// operator!=
-	// operator<
-	// operator>
-	// operator<=
-	// operator>=
-	//
-	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator==(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
-		return lhs.compare(rhs) == 0;
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator==(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
-		return lhs.compare(rhs) == 0;
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator==(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
-		return 0 == rhs.compare(lhs);
-	}
-	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator!=(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
-		return !(lhs == rhs);
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator!=(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
-		return !(lhs == rhs);
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator!=(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
-		return !(lhs == rhs);
-	}
-	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator<(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
-		return lhs.compare(rhs) < 0;
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator<(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
-		return lhs.compare(rhs) < 0;
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator<(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
-		return 0 < rhs.compare(lhs);
-	}
-	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator>(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
-		return rhs < lhs;
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator>(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
-		return rhs < lhs;
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator>(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
-		return rhs < lhs;
-	}
-	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator<=(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
-		return !(rhs < lhs);
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator<=(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
-		return !(rhs < lhs);
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator<=(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
-		return !(rhs < lhs);
-	}
-	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator>=(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
-		return !(lhs < rhs);
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator>=(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
-		return !(lhs < rhs);
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR bool operator>=(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
-		return !(lhs < rhs);
-	}
-
-	//
-	// swap
-	//
-	template<typename T, std::size_t N, typename Traits>
-	inline void swap(
-		sprout::basic_string<T, N, Traits>& lhs,
-		sprout::basic_string<T, N, Traits>& rhs
-		) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
-	{
-		lhs.swap(rhs);
-	}
-
-	//
-	// operator>>
-	// operator<<
-	//
-	template<typename T, std::size_t N, typename Traits, typename StreamTraits>
-	inline std::basic_istream<T, StreamTraits>& operator>>(std::basic_istream<T, StreamTraits>& lhs, sprout::basic_string<T, N, Traits>& rhs) {
-		typedef T elem_type;
-		typedef StreamTraits traits_type;
-		typedef std::basic_istream<T, StreamTraits> istream_type;
-		typedef sprout::basic_string<T, N, Traits> string_type;
-		typedef std::ctype<elem_type> ctype_type;
-		typedef typename string_type::size_type size_type;
-		std::ios_base::iostate state = std::ios_base::goodbit;
-		bool changed = false;
-		size_type current = 0;
-		if (typename istream_type::sentry(lhs)) {
-			ctype_type const& ctype_fac = std::use_facet<ctype_type>(lhs.getloc());
-			try {
-				size_type remain = 0 < lhs.width() && static_cast<size_type>(lhs.width()) < rhs.max_size()
-					? static_cast<size_type>(lhs.width())
-					: rhs.max_size()
-					;
-				typename traits_type::int_type meta = lhs.rdbuf()->sgetc();
-				for (; remain; --remain, meta = lhs.rdbuf()->snextc())
-					if (traits_type::eq_int_type(traits_type::eof(), meta)) {
-						state |= std::ios_base::eofbit;
-						break;
-					} else if (ctype_fac.is(ctype_type::space, traits_type::to_char_type(meta))) {
-						break;
-					} else {
-						rhs[current] = traits_type::to_char_type(meta);
-						changed = true;
-						++current;
-					}
-			} catch (...) {
-				state |= std::ios_base::badbit;
-			}
-		}
-		lhs.width(0);
-		if (!changed) {
-			state |= std::ios_base::failbit;
-		}
-		lhs.setstate(state);
-		rhs.len = current;
-		for (; current != rhs.max_size(); ++current) {
-			rhs[current] = T();
-		}
-		return lhs;
-	}
-	template<typename T, std::size_t N, typename Traits, typename StreamTraits>
-	inline std::basic_ostream<T, StreamTraits>& operator<<(std::basic_ostream<T, StreamTraits>& lhs, sprout::basic_string<T, N, Traits> const& rhs) {
-		return lhs << rhs.c_str();
-	}
-
-	namespace detail {
-		template<typename Container>
-		struct make_construct_impl;
-
-		template<typename T, std::size_t N, typename Traits>
-		struct make_construct_impl<sprout::basic_string<T, N, Traits> > {
-		private:
-			typedef sprout::basic_string<T, N, Traits> copied_type;
-		private:
-			template<std::size_t S>
-			static SPROUT_CONSTEXPR copied_type make_impl(typename copied_type::size_type size) {
-				return copied_type{{}, size};
-			}
-			template<std::size_t S, typename Head, typename... Tail>
-			static SPROUT_CONSTEXPR typename std::enable_if<
-				S == sizeof...(Tail),
-				copied_type
-			>::type make_impl(typename copied_type::size_type size, Head&& head, Tail&&... tail) {
-				return copied_type{{sprout::forward<Tail>(tail)..., sprout::forward<Head>(head)}, size};
-			}
-			template<std::size_t S, typename Head, typename... Tail>
-			static SPROUT_CONSTEXPR typename std::enable_if<
-				S != sizeof...(Tail),
-				copied_type
-			>::type make_impl(typename copied_type::size_type size, Head&& head, Tail&&... tail) {
-				return make_impl<S + 1>(size, sprout::forward<Tail>(tail)..., S >= size ? T() : sprout::forward<Head>(head));
-			}
-		public:
-			static SPROUT_CONSTEXPR typename copied_type::size_type length() {
-				return 0;
-			}
-			template<typename... Tail>
-			static SPROUT_CONSTEXPR typename copied_type::size_type length(T const& head, Tail&&... tail) {
-				return !head ? 0 : 1 + length(sprout::forward<Tail>(tail)...);
-			}
-			template<typename... Args>
-			static SPROUT_CONSTEXPR copied_type make(typename copied_type::size_type size, Args&&... args) {
-				return make_impl<0>(size, sprout::forward<Args>(args)...);
-			}
-		};
-	}	// namespace detail
-
-	//
-	// container_construct_traits
-	//
-	template<typename T, std::size_t N, typename Traits>
-	struct container_construct_traits<sprout::basic_string<T, N, Traits> > {
-	public:
-		typedef sprout::basic_string<T, N, Traits> copied_type;
-	public:
-		template<typename Cont>
-		static SPROUT_CONSTEXPR copied_type deep_copy(Cont&& cont) {
-			return sprout::forward<Cont>(cont);
-		}
-		template<typename... Args>
-		static SPROUT_CONSTEXPR copied_type make(Args&&... args) {
-			typedef sprout::detail::make_construct_impl<copied_type> impl_type;
-			return impl_type::make(impl_type::length(sprout::forward<Args>(args)...), sprout::forward<Args>(args)...);
-		}
-		template<typename Cont, typename... Args>
-		static SPROUT_CONSTEXPR copied_type remake(
-			Cont&& cont,
-			typename sprout::container_traits<sprout::basic_string<T, N, Traits> >::difference_type size,
-			Args&&... args
-			)
-		{
-			typedef sprout::detail::make_construct_impl<copied_type> impl_type;
-			return impl_type::make(size, sprout::forward<Args>(args)...);
-		}
-	};
-
-	//
-	// container_transform_traits
-	//
-	template<typename T, std::size_t N, typename Traits>
-	struct container_transform_traits<sprout::basic_string<T, N, Traits> > {
-	public:
-		template<typename sprout::container_traits<sprout::basic_string<T, N, Traits> >::size_type Size>
-		struct rebind_size {
-		public:
-			typedef sprout::basic_string<T, Size, Traits> type;
-		};
-	};
-
-	//
-	// to_string
-	//
-	namespace detail {
-		template<typename T, std::size_t N, sprout::index_t... Indexes>
-		inline SPROUT_CONSTEXPR sprout::basic_string<T, N - 1> to_string_impl_1(
-			T const(& arr)[N],
-			typename sprout::basic_string<T, N - 1>::size_type n,
-			sprout::index_tuple<Indexes...>
-			)
-		{
-			return sprout::basic_string<T, N - 1>{{(Indexes < n ? arr[Indexes] : T())...}, n};
-		}
-		template<typename T, std::size_t N, sprout::index_t... Indexes>
-		inline SPROUT_CONSTEXPR sprout::basic_string<T, N - 1> to_string_impl(
-			T const(& arr)[N],
-			sprout::index_tuple<Indexes...>
-			)
-		{
-			return to_string_impl_1(arr, sprout::char_traits<T>::length(arr), sprout::index_tuple<Indexes...>());
-		}
-	}	// namespace detail
-	template<typename T, std::size_t N>
-	inline SPROUT_CONSTEXPR sprout::basic_string<T, N - 1> to_string(T const(& arr)[N]) {
-		return sprout::detail::to_string_impl(arr, typename sprout::index_range<0, N - 1>::type());
-	}
-
-	//
-	// string_from_c_str
-	//
-	template<std::size_t N, typename T>
-	inline SPROUT_CONSTEXPR sprout::basic_string<T, N> string_from_c_str(T const* s, std::size_t n) {
-		return sprout::basic_string<T, N>::from_c_str(s, n);
-	}
-	template<std::size_t N, typename T>
-	inline SPROUT_CONSTEXPR sprout::basic_string<T, N> string_from_c_str(T const* s) {
-		return sprout::basic_string<T, N>::from_c_str(s);
-	}
-
-	//
-	// make_string
-	//
-	namespace detail {
-		template<typename T, std::size_t N, sprout::index_t... Indexes>
-		inline SPROUT_CONSTEXPR sprout::basic_string<T, N - 1> make_string_impl_1(
-			sprout::array<T, N> const& arr,
-			std::size_t n,
-			sprout::index_tuple<Indexes...>
-			)
-		{
-			return sprout::basic_string<T, N - 1>{{(Indexes < n ? arr[Indexes] : T())...}, n};
-		}
-		template<typename T, std::size_t N, sprout::index_t... Indexes>
-		inline SPROUT_CONSTEXPR sprout::basic_string<T, N - 1> make_string_impl(
-			sprout::array<T, N> const& arr,
-			sprout::index_tuple<Indexes...>
-			)
-		{
-			return sprout::detail::make_string_impl_1(
-				arr,
-				sprout::char_traits<T>::length(arr.begin()),
-				sprout::index_tuple<Indexes...>()
-				);
-		}
-	}	// namespace detail
-	template<typename T, typename... Types>
-	inline SPROUT_CONSTEXPR sprout::basic_string<typename std::decay<T>::type, 1 + sizeof...(Types)>
-	make_string(T&& t, Types&&... args) {
-		return sprout::detail::make_string_impl(
-			sprout::make_array<typename std::decay<T>::type>(
-				sprout::forward<T>(t),
-				sprout::forward<Types>(args)...,
-				typename std::decay<T>::type()
-				),
-			typename sprout::index_range<0, 1 + sizeof...(Types)>::type()
-			);
-	}
-
-	//
-	// make_string_as
-	//
-	template<typename T>
-	inline SPROUT_CONSTEXPR sprout::basic_string<typename std::decay<T>::type, 0>
-	make_string_as() {
-		return sprout::basic_string<typename std::decay<T>::type, 0>{};
-	}
-	template<typename T, typename... Types>
-	inline SPROUT_CONSTEXPR sprout::basic_string<typename std::decay<T>::type, sizeof...(Types)>
-	make_string_as(Types&&... args) {
-		return sprout::detail::make_string_impl(
-			sprout::make_array<typename std::decay<T>::type>(
-				sprout::forward<Types>(args)...,
-				typename std::decay<T>::type()
-				),
-			typename sprout::index_range<0, 1 + sizeof...(Types)>::type()
-			);
-	}
-
-	//
-	// operator+
-	//
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::push_back<sprout::basic_string<T, N, Traits>, T>::type operator+(
-		sprout::basic_string<T, N, Traits> const& lhs,
-		T const& rhs
-		)
-	{
-		return sprout::fixed::push_back(lhs, rhs);
-	}
-	template<typename T, std::size_t N, typename Traits>
-	inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::push_front<sprout::basic_string<T, N, Traits>, T>::type operator+(
-		T const& lhs,
-		sprout::basic_string<T, N, Traits> const& rhs
-		)
-	{
-		return sprout::fixed::push_front(rhs, lhs);
-	}
-	template<typename T, std::size_t N, typename Traits, std::size_t N2>
-	inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::append_back<
-			sprout::basic_string<T, N, Traits>,
-			sprout::basic_string<T, N2 - 1, Traits>
-	>::type operator+(
-		sprout::basic_string<T, N, Traits> const& lhs,
-		T const (& rhs)[N2]
-		)
-	{
-		return sprout::fixed::append_back(lhs, sprout::to_string(rhs));
-	}
-	template<typename T, std::size_t N, typename Traits, std::size_t N2>
-	inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::append_front<
-		sprout::basic_string<T, N, Traits>,
-		sprout::basic_string<T, N2 - 1, Traits>
-	>::type operator+(
-		T const (& lhs)[N2],
-		sprout::basic_string<T, N, Traits> const& rhs
-		)
-	{
-		return sprout::fixed::append_front(rhs, sprout::to_string(lhs));
-	}
-	template<typename T, std::size_t N, typename Traits, std::size_t N2>
-	inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::append_back<
-		sprout::basic_string<T, N, Traits>,
-		sprout::basic_string<T, N2, Traits>
-	>::type operator+(
-		sprout::basic_string<T, N, Traits> const& lhs,
-		sprout::basic_string<T, N2, Traits> const& rhs
-		)
-	{
-		return sprout::fixed::append_back(lhs, rhs);
-	}
-
-	//
-	// string_t
-	//
-	template<std::size_t N>
-	struct string_t {
-	public:
-		typedef sprout::basic_string<char, N> type;
-	};
-	//
-	// wstring_t
-	//
-	template<std::size_t N>
-	struct wstring_t {
-	public:
-		typedef sprout::basic_string<wchar_t, N> type;
-	};
-	//
-	// u16string_t
-	//
-	template<std::size_t N>
-	struct u16string_t {
-	public:
-		typedef sprout::basic_string<char16_t, N> type;
-	};
-	//
-	// u32string_t
-	//
-	template<std::size_t N>
-	struct u32string_t {
-	public:
-		typedef sprout::basic_string<char32_t, N> type;
-	};
-
-	//
-	// is_basic_string
-	//
-	template<typename T>
-	struct is_basic_string
-		: public std::false_type
-	{};
-	template<typename T>
-	struct is_basic_string<T const>
-		: public sprout::is_basic_string<T>
-	{};
-	template<typename T>
-	struct is_basic_string<T const volatile>
-		: public sprout::is_basic_string<T>
-	{};
-	template<typename T, std::size_t N, typename Traits>
-	struct is_basic_string<sprout::basic_string<T, N, Traits> >
-		: public std::true_type
-	{};
-
-	//
-	// is_string_of
-	//
-	template<typename T, typename Elem>
-	struct is_string_of
-		: public std::false_type
-	{};
-	template<typename T, typename Elem>
-	struct is_string_of<T const, Elem>
-		: public sprout::is_string_of<T, Elem>
-	{};
-	template<typename T, typename Elem>
-	struct is_string_of<T const volatile, Elem>
-		: public sprout::is_string_of<T, Elem>
-	{};
-	template<typename T, std::size_t N, typename Traits, typename Elem>
-	struct is_string_of<sprout::basic_string<T, N, Traits>, Elem>
-		: public std::true_type
-	{};
-
-	//
-	// is_string
-	//
-	template<typename T>
-	struct is_string
-		: public sprout::is_string_of<T, char>
-	{};
-	//
-	// is_wstring
-	//
-	template<typename T>
-	struct is_wstring
-		: public sprout::is_string_of<T, wchar_t>
-	{};
-	//
-	// is_u16string
-	//
-	template<typename T>
-	struct is_u16string
-		: public sprout::is_string_of<T, char16_t>
-	{};
-	//
-	// is_u32string
-	//
-	template<typename T>
-	struct is_u32string
-		: public sprout::is_string_of<T, char32_t>
-	{};
-}	// namespace sprout
-
-namespace std {
-	//
-	// tuple_size
-	//
-	template<typename T, std::size_t N, typename Traits>
-	struct tuple_size<sprout::basic_string<T, N, Traits> >
-		: public std::integral_constant<std::size_t, N>
-	{};
-
-	//
-	// tuple_element
-	//
-	template<std::size_t I, typename T, std::size_t N, typename Traits>
-	struct tuple_element<I, sprout::basic_string<T, N, Traits> > {
-	public:
-		static_assert(I < N, "tuple_element<>: index out of range");
-		typedef T type;
-	};
-}	// namespace std
-
+#include <sprout/string/char_traits.hpp>
+#include <sprout/string/string.hpp>
+#include <sprout/string/comparison.hpp>
+#include <sprout/string/concat.hpp>
+#include <sprout/string/io.hpp>
+#include <sprout/string/hash.hpp>
+#include <sprout/string/tuple.hpp>
+#include <sprout/string/container.hpp>
+#include <sprout/string/make_string.hpp>
+#include <sprout/string/to_string.hpp>
+#include <sprout/string/type_traits.hpp>
 #include <sprout/string/alias.hpp>
 
 #endif	// #ifndef SPROUT_STRING_HPP
diff --git a/sprout/string/alias.hpp b/sprout/string/alias.hpp
index b80d3a82..d9fd74e4 100644
--- a/sprout/string/alias.hpp
+++ b/sprout/string/alias.hpp
@@ -2,13 +2,14 @@
 #define SPROUT_STRING_ALIAS_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/string.hpp>
 
 #if SPROUT_USE_TEMPLATE_ALIASES
-
-#include <cstddef>
+#	include <cstddef>
+#	include <sprout/string/string.hpp>
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
 
 namespace sprout {
+#if SPROUT_USE_TEMPLATE_ALIASES
 	//
 	// string
 	//
@@ -29,8 +30,7 @@ namespace sprout {
 	//
 	template<std::size_t N>
 	using u32string = sprout::basic_string<char32_t, N>;
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
 }	// namespace sprout
 
-#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
-
 #endif	// #ifndef SPROUT_STRING_ALIAS_HPP
diff --git a/sprout/string/char_traits.hpp b/sprout/string/char_traits.hpp
new file mode 100644
index 00000000..40fb91f5
--- /dev/null
+++ b/sprout/string/char_traits.hpp
@@ -0,0 +1,132 @@
+#ifndef SPROUT_STRING_CHAR_TRAITS_HPP
+#define SPROUT_STRING_CHAR_TRAITS_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <string>
+#include <sprout/config.hpp>
+
+namespace sprout {
+	//
+	// char_traits
+	//
+	template<typename Char>
+	class char_traits {
+	private:
+		typedef std::char_traits<Char> impl_type;
+	public:
+		typedef typename impl_type::char_type char_type;
+		typedef typename impl_type::int_type int_type;
+		typedef typename impl_type::off_type off_type;
+		typedef typename impl_type::pos_type pos_type;
+		typedef typename impl_type::state_type state_type;
+	public:
+		static void assign(char_type& c1, char_type const& c2) SPROUT_NOEXCEPT {
+			impl_type::assign(c1, c2);
+		}
+		static SPROUT_CONSTEXPR bool eq(char_type c1, char_type c2) SPROUT_NOEXCEPT {
+			return impl_type::eq(c1, c2);
+		}
+		static SPROUT_CONSTEXPR bool lt(char_type c1, char_type c2) SPROUT_NOEXCEPT {
+			return impl_type::lt(c1, c2);
+		}
+		static SPROUT_CONSTEXPR int compare(char_type const* s1, char_type const* s2, std::size_t n) {
+			return !n ? 0
+				: lt(*s1, *s2) ? -1
+				: lt(*s2, *s1) ? 1
+				: compare(s1 + 1, s2 + 1, n - 1)
+				;
+		}
+		static SPROUT_CONSTEXPR std::size_t length(char_type const* s) {
+			return !*s ? 0
+				: 1 + length(s + 1)
+				;
+		}
+		static SPROUT_CONSTEXPR char_type const* find(char_type const* s, std::size_t n, char_type const& a) {
+			return !n ? nullptr
+				: eq(*s, a) ? s
+				: find(s + 1, n - 1, a)
+				;
+		}
+		static char_type* move(char_type* s1, char_type const* s2, std::size_t n) {
+			return impl_type::move(s1, s2, n);
+		}
+		static char_type* copy(char_type* s1, char_type const* s2, std::size_t n) {
+			return impl_type::copy(s1, s2, n);
+		}
+		static char_type* assign(char_type* s, std::size_t n, char_type a) {
+			return impl_type::assign(s, n, a);
+		}
+		static SPROUT_CONSTEXPR int_type not_eof(int_type c) SPROUT_NOEXCEPT {
+			return impl_type::not_eof(c);
+		}
+		static SPROUT_CONSTEXPR char_type to_char_type(int_type c) SPROUT_NOEXCEPT {
+			return impl_type::to_char_type(c);
+		}
+		static SPROUT_CONSTEXPR int_type to_int_type(char_type c) SPROUT_NOEXCEPT {
+			return impl_type::to_int_type(c);
+		}
+		static SPROUT_CONSTEXPR bool eq_int_type(int_type c1, int_type c2) SPROUT_NOEXCEPT {
+			return impl_type::eq_int_type(c1, c2);
+		}
+		static SPROUT_CONSTEXPR int_type eof() SPROUT_NOEXCEPT {
+			return impl_type::eof();
+		}
+#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
+		template<typename ConstIterator>
+		static SPROUT_CONSTEXPR int compare(char_type const* s1, ConstIterator s2, std::size_t n) {
+			return !n ? 0
+				: lt(*s1, *s2) ? -1
+				: lt(*s2, *s1) ? 1
+				: compare(s1 + 1, s2 + 1, n - 1)
+				;
+		}
+		template<typename ConstIterator>
+		static SPROUT_CONSTEXPR int compare(ConstIterator s1, char_type const* s2, std::size_t n) {
+			return !n ? 0
+				: lt(*s1, *s2) ? -1
+				: lt(*s2, *s1) ? 1
+				: compare(s1 + 1, s2 + 1, n - 1)
+				;
+		}
+		template<typename ConstIterator1, typename ConstIterator2>
+		static SPROUT_CONSTEXPR int compare(ConstIterator1 s1, ConstIterator2 s2, std::size_t n) {
+			return !n ? 0
+				: lt(*s1, *s2) ? -1
+				: lt(*s2, *s1) ? 1
+				: compare(s1 + 1, s2 + 1, n - 1)
+				;
+		}
+		template<typename ConstIterator>
+		static SPROUT_CONSTEXPR std::size_t length(ConstIterator s) {
+			return !*s ? 0
+				: 1 + length(s + 1)
+				;
+		}
+		template<typename ConstIterator>
+		static SPROUT_CONSTEXPR ConstIterator find(ConstIterator s, std::size_t n, char_type const& a) {
+			return !n ? nullptr
+				: eq(*s, a) ? s
+				: find(s + 1, n - 1, a)
+				;
+		}
+		template<typename Iterator, typename ConstIterator>
+		static Iterator move(Iterator s1, ConstIterator s2, std::size_t n) {
+			std::copy_backward(s2, s2 + n, s1);
+			return s1;
+		}
+		template<typename Iterator, typename ConstIterator>
+		static Iterator copy(Iterator s1, ConstIterator s2, std::size_t n) {
+			std::copy(s2, s2 + n, s1);
+			return s1;
+		}
+		template<typename Iterator>
+		static Iterator assign(Iterator s, std::size_t n, char_type a) {
+			std::fill(s, s + n, a);
+			return s;
+		}
+#endif
+	};
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_STRING_CHAR_TRAITS_HPP
diff --git a/sprout/string/comparison.hpp b/sprout/string/comparison.hpp
new file mode 100644
index 00000000..bbef6f16
--- /dev/null
+++ b/sprout/string/comparison.hpp
@@ -0,0 +1,91 @@
+#ifndef SPROUT_STRING_COMPARISON_HPP
+#define SPROUT_STRING_COMPARISON_HPP
+
+#include <cstddef>
+#include <sprout/config.hpp>
+#include <sprout/string/string.hpp>
+
+namespace sprout {
+	//
+	// operator==
+	// operator!=
+	// operator<
+	// operator>
+	// operator<=
+	// operator>=
+	//
+	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator==(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
+		return lhs.compare(rhs) == 0;
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator==(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
+		return lhs.compare(rhs) == 0;
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator==(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
+		return 0 == rhs.compare(lhs);
+	}
+	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator!=(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
+		return !(lhs == rhs);
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator!=(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
+		return !(lhs == rhs);
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator!=(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
+		return !(lhs == rhs);
+	}
+	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator<(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
+		return lhs.compare(rhs) < 0;
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator<(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
+		return lhs.compare(rhs) < 0;
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator<(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
+		return 0 < rhs.compare(lhs);
+	}
+	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator>(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
+		return rhs < lhs;
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator>(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
+		return rhs < lhs;
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator>(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
+		return rhs < lhs;
+	}
+	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator<=(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
+		return !(rhs < lhs);
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator<=(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
+		return !(rhs < lhs);
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator<=(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
+		return !(rhs < lhs);
+	}
+	template<typename T, std::size_t N1, std::size_t N2, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator>=(sprout::basic_string<T, N1, Traits> const& lhs, sprout::basic_string<T, N2, Traits> const& rhs) {
+		return !(lhs < rhs);
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator>=(sprout::basic_string<T, N, Traits> const& lhs, T const* rhs) {
+		return !(lhs < rhs);
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR bool operator>=(T const* lhs, sprout::basic_string<T, N, Traits> const& rhs) {
+		return !(lhs < rhs);
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_STRING_COMPARISON_HPP
diff --git a/sprout/string/concat.hpp b/sprout/string/concat.hpp
new file mode 100644
index 00000000..bfeec563
--- /dev/null
+++ b/sprout/string/concat.hpp
@@ -0,0 +1,68 @@
+#ifndef SPROUT_STRING_CONCAT_HPP
+#define SPROUT_STRING_CONCAT_HPP
+
+#include <cstddef>
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/string/string.hpp>
+#include <sprout/operation/fixed/push_back.hpp>
+#include <sprout/operation/fixed/push_front.hpp>
+#include <sprout/operation/fixed/append_back.hpp>
+#include <sprout/operation/fixed/append_front.hpp>
+
+namespace sprout {
+	//
+	// operator+
+	//
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::push_back<sprout::basic_string<T, N, Traits>, T>::type operator+(
+		sprout::basic_string<T, N, Traits> const& lhs,
+		T const& rhs
+		)
+	{
+		return sprout::fixed::push_back(lhs, rhs);
+	}
+	template<typename T, std::size_t N, typename Traits>
+	inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::push_front<sprout::basic_string<T, N, Traits>, T>::type operator+(
+		T const& lhs,
+		sprout::basic_string<T, N, Traits> const& rhs
+		)
+	{
+		return sprout::fixed::push_front(rhs, lhs);
+	}
+	template<typename T, std::size_t N, typename Traits, std::size_t N2>
+	inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::append_back<
+			sprout::basic_string<T, N, Traits>,
+			sprout::basic_string<T, N2 - 1, Traits>
+	>::type operator+(
+		sprout::basic_string<T, N, Traits> const& lhs,
+		T const (& rhs)[N2]
+		)
+	{
+		return sprout::fixed::append_back(lhs, sprout::to_string(rhs));
+	}
+	template<typename T, std::size_t N, typename Traits, std::size_t N2>
+	inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::append_front<
+		sprout::basic_string<T, N, Traits>,
+		sprout::basic_string<T, N2 - 1, Traits>
+	>::type operator+(
+		T const (& lhs)[N2],
+		sprout::basic_string<T, N, Traits> const& rhs
+		)
+	{
+		return sprout::fixed::append_front(rhs, sprout::to_string(lhs));
+	}
+	template<typename T, std::size_t N, typename Traits, std::size_t N2>
+	inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::append_back<
+		sprout::basic_string<T, N, Traits>,
+		sprout::basic_string<T, N2, Traits>
+	>::type operator+(
+		sprout::basic_string<T, N, Traits> const& lhs,
+		sprout::basic_string<T, N2, Traits> const& rhs
+		)
+	{
+		return sprout::fixed::append_back(lhs, rhs);
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_STRING_CONCAT_HPP
diff --git a/sprout/string/container.hpp b/sprout/string/container.hpp
new file mode 100644
index 00000000..b443153d
--- /dev/null
+++ b/sprout/string/container.hpp
@@ -0,0 +1,54 @@
+#ifndef SPROUT_STRING_CONTAINER_HPP
+#define SPROUT_STRING_CONTAINER_HPP
+
+#include <cstddef>
+#include <type_traits>
+#include <sprout/utility/forward.hpp>
+#include <sprout/string/string.hpp>
+#include <sprout/container/traits.hpp>
+
+namespace sprout {
+	//
+	// container_construct_traits
+	//
+	template<typename T, std::size_t N, typename Traits>
+	struct container_construct_traits<sprout::basic_string<T, N, Traits> > {
+	public:
+		typedef sprout::basic_string<T, N, Traits> copied_type;
+	public:
+		template<typename Cont>
+		static SPROUT_CONSTEXPR copied_type deep_copy(Cont&& cont) {
+			return sprout::forward<Cont>(cont);
+		}
+		template<typename... Args>
+		static SPROUT_CONSTEXPR copied_type make(Args&&... args) {
+			typedef sprout::detail::make_construct_impl<copied_type> impl_type;
+			return impl_type::make(impl_type::length(sprout::forward<Args>(args)...), sprout::forward<Args>(args)...);
+		}
+		template<typename Cont, typename... Args>
+		static SPROUT_CONSTEXPR copied_type remake(
+			Cont&& cont,
+			typename sprout::container_traits<sprout::basic_string<T, N, Traits> >::difference_type size,
+			Args&&... args
+			)
+		{
+			typedef sprout::detail::make_construct_impl<copied_type> impl_type;
+			return impl_type::make(size, sprout::forward<Args>(args)...);
+		}
+	};
+
+	//
+	// container_transform_traits
+	//
+	template<typename T, std::size_t N, typename Traits>
+	struct container_transform_traits<sprout::basic_string<T, N, Traits> > {
+	public:
+		template<typename sprout::container_traits<sprout::basic_string<T, N, Traits> >::size_type Size>
+		struct rebind_size {
+		public:
+			typedef sprout::basic_string<T, Size, Traits> type;
+		};
+	};
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_STRING_CONTAINER_HPP
diff --git a/sprout/string/hash.hpp b/sprout/string/hash.hpp
new file mode 100644
index 00000000..4d61a5e1
--- /dev/null
+++ b/sprout/string/hash.hpp
@@ -0,0 +1,18 @@
+#ifndef SPROUT_STRING_HASH_HPP
+#define SPROUT_STRING_HASH_HPP
+
+#include <cstddef>
+#include <sprout/string/string.hpp>
+#include <sprout/functional/hash/hash.hpp>
+
+namespace sprout {
+	//
+	// hash_value
+	//
+	template<typename T, std::size_t N, typename Traits>
+	SPROUT_CONSTEXPR std::size_t hash_value(sprout::basic_string<T, N, Traits> const& v) {
+		return sprout::hash_range(v.begin(), v.end());
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_STRING_HASH_HPP
diff --git a/sprout/string/io.hpp b/sprout/string/io.hpp
new file mode 100644
index 00000000..7ae1a389
--- /dev/null
+++ b/sprout/string/io.hpp
@@ -0,0 +1,65 @@
+#ifndef SPROUT_STRING_IO_HPP
+#define SPROUT_STRING_IO_HPP
+
+#include <cstddef>
+#include <ios>
+#include <sprout/config.hpp>
+#include <sprout/string/string.hpp>
+
+namespace sprout {
+	//
+	// operator>>
+	// operator<<
+	//
+	template<typename T, std::size_t N, typename Traits, typename StreamTraits>
+	inline std::basic_istream<T, StreamTraits>& operator>>(std::basic_istream<T, StreamTraits>& lhs, sprout::basic_string<T, N, Traits>& rhs) {
+		typedef T elem_type;
+		typedef StreamTraits traits_type;
+		typedef std::basic_istream<T, StreamTraits> istream_type;
+		typedef sprout::basic_string<T, N, Traits> string_type;
+		typedef std::ctype<elem_type> ctype_type;
+		typedef typename string_type::size_type size_type;
+		std::ios_base::iostate state = std::ios_base::goodbit;
+		bool changed = false;
+		size_type current = 0;
+		if (typename istream_type::sentry(lhs)) {
+			ctype_type const& ctype_fac = std::use_facet<ctype_type>(lhs.getloc());
+			try {
+				size_type remain = 0 < lhs.width() && static_cast<size_type>(lhs.width()) < rhs.max_size()
+					? static_cast<size_type>(lhs.width())
+					: rhs.max_size()
+					;
+				typename traits_type::int_type meta = lhs.rdbuf()->sgetc();
+				for (; remain; --remain, meta = lhs.rdbuf()->snextc())
+					if (traits_type::eq_int_type(traits_type::eof(), meta)) {
+						state |= std::ios_base::eofbit;
+						break;
+					} else if (ctype_fac.is(ctype_type::space, traits_type::to_char_type(meta))) {
+						break;
+					} else {
+						rhs[current] = traits_type::to_char_type(meta);
+						changed = true;
+						++current;
+					}
+			} catch (...) {
+				state |= std::ios_base::badbit;
+			}
+		}
+		lhs.width(0);
+		if (!changed) {
+			state |= std::ios_base::failbit;
+		}
+		lhs.setstate(state);
+		rhs.len = current;
+		for (; current != rhs.max_size(); ++current) {
+			rhs[current] = T();
+		}
+		return lhs;
+	}
+	template<typename T, std::size_t N, typename Traits, typename StreamTraits>
+	inline std::basic_ostream<T, StreamTraits>& operator<<(std::basic_ostream<T, StreamTraits>& lhs, sprout::basic_string<T, N, Traits> const& rhs) {
+		return lhs << rhs.c_str();
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_STRING_IO_HPP
diff --git a/sprout/string/make_string.hpp b/sprout/string/make_string.hpp
new file mode 100644
index 00000000..1bb49c57
--- /dev/null
+++ b/sprout/string/make_string.hpp
@@ -0,0 +1,74 @@
+#ifndef SPROUT_STRING_MAKE_STRING_HPP
+#define SPROUT_STRING_MAKE_STRING_HPP
+
+#include <cstddef>
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/index_tuple.hpp>
+#include <sprout/array.hpp>
+#include <sprout/string/char_traits.hpp>
+#include <sprout/string/string.hpp>
+#include <sprout/utility/forward.hpp>
+
+namespace sprout {
+	//
+	// make_string
+	//
+	namespace detail {
+		template<typename T, std::size_t N, sprout::index_t... Indexes>
+		inline SPROUT_CONSTEXPR sprout::basic_string<T, N - 1> make_string_impl_1(
+			sprout::array<T, N> const& arr,
+			std::size_t n,
+			sprout::index_tuple<Indexes...>
+			)
+		{
+			return sprout::basic_string<T, N - 1>{{(Indexes < n ? arr[Indexes] : T())...}, n};
+		}
+		template<typename T, std::size_t N, sprout::index_t... Indexes>
+		inline SPROUT_CONSTEXPR sprout::basic_string<T, N - 1> make_string_impl(
+			sprout::array<T, N> const& arr,
+			sprout::index_tuple<Indexes...>
+			)
+		{
+			return sprout::detail::make_string_impl_1(
+				arr,
+				sprout::char_traits<T>::length(arr.begin()),
+				sprout::index_tuple<Indexes...>()
+				);
+		}
+	}	// namespace detail
+	template<typename T, typename... Types>
+	inline SPROUT_CONSTEXPR sprout::basic_string<typename std::decay<T>::type, 1 + sizeof...(Types)>
+	make_string(T&& t, Types&&... args) {
+		return sprout::detail::make_string_impl(
+			sprout::make_array<typename std::decay<T>::type>(
+				sprout::forward<T>(t),
+				sprout::forward<Types>(args)...,
+				typename std::decay<T>::type()
+				),
+			typename sprout::index_range<0, 1 + sizeof...(Types)>::type()
+			);
+	}
+
+	//
+	// make_string_as
+	//
+	template<typename T>
+	inline SPROUT_CONSTEXPR sprout::basic_string<typename std::decay<T>::type, 0>
+	make_string_as() {
+		return sprout::basic_string<typename std::decay<T>::type, 0>{};
+	}
+	template<typename T, typename... Types>
+	inline SPROUT_CONSTEXPR sprout::basic_string<typename std::decay<T>::type, sizeof...(Types)>
+	make_string_as(Types&&... args) {
+		return sprout::detail::make_string_impl(
+			sprout::make_array<typename std::decay<T>::type>(
+				sprout::forward<Types>(args)...,
+				typename std::decay<T>::type()
+				),
+			typename sprout::index_range<0, 1 + sizeof...(Types)>::type()
+			);
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_STRING_MAKE_STRING_HPP
diff --git a/sprout/string/string.hpp b/sprout/string/string.hpp
new file mode 100644
index 00000000..4df033e6
--- /dev/null
+++ b/sprout/string/string.hpp
@@ -0,0 +1,529 @@
+#ifndef SPROUT_STRING_STRING_HPP
+#define SPROUT_STRING_STRING_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <utility>
+#include <stdexcept>
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/index_tuple.hpp>
+#include <sprout/iterator/reverse_iterator.hpp>
+#include <sprout/utility/forward.hpp>
+#include <sprout/string/char_traits.hpp>
+#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT
+#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
+#	include <sprout/iterator/index_iterator.hpp>
+#endif
+
+namespace sprout {
+	//
+	// basic_string
+	//
+	template<typename T, std::size_t N, typename Traits = sprout::char_traits<T> >
+	class basic_string {
+	public:
+		typedef T value_type;
+#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
+		typedef sprout::index_iterator<basic_string&> iterator;
+		typedef sprout::index_iterator<basic_string const&> const_iterator;
+#else
+		typedef T* iterator;
+		typedef T const* const_iterator;
+#endif
+		typedef T& reference;
+		typedef T const& const_reference;
+		typedef std::size_t size_type;
+		typedef std::ptrdiff_t difference_type;
+		typedef T* pointer;
+		typedef T const* const_pointer;
+		typedef sprout::reverse_iterator<iterator> reverse_iterator;
+		typedef sprout::reverse_iterator<const_iterator> const_reverse_iterator;
+		typedef Traits traits_type;
+	public:
+		SPROUT_STATIC_CONSTEXPR size_type npos = -1;
+		SPROUT_STATIC_CONSTEXPR size_type static_size = N;
+	private:
+		static SPROUT_CONSTEXPR int compare_impl_2(int compared, size_type n1, size_type n2) {
+			return compared != 0 ? compared
+				: n1 < n2 ? -1
+				: n2 < n1 ? 1
+				: 0
+				;
+		}
+		static SPROUT_CONSTEXPR int compare_impl_1(value_type const* dest, size_type pos1, size_type n1, value_type const* s, size_type n2) {
+			return compare_impl_2(
+				traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
+				n1,
+				n2
+				);
+		}
+		template<sprout::index_t... Indexes>
+		static SPROUT_CONSTEXPR basic_string<T, N, Traits> from_c_str_impl(
+			value_type const* s,
+			size_type n,
+			sprout::index_tuple<Indexes...>
+			)
+		{
+			return sprout::basic_string<T, N, Traits>{{(Indexes < n ? s[Indexes] : T())...}, n};
+		}
+#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
+		template<typename ConstIterator>
+		static SPROUT_CONSTEXPR typename std::enable_if<
+			sprout::is_index_iterator<ConstIterator>::value,
+			int
+		>::type compare_impl_1(value_type const* dest, size_type pos1, size_type n1, ConstIterator s, size_type n2) {
+			return compare_impl_2(
+				traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
+				n1,
+				n2
+				);
+		}
+		static SPROUT_CONSTEXPR int compare_impl_1(const_iterator dest, size_type pos1, size_type n1, value_type const* s, size_type n2) {
+			return compare_impl_2(
+				traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
+				n1,
+				n2
+				);
+		}
+		template<typename ConstIterator>
+		static SPROUT_CONSTEXPR typename std::enable_if<
+			sprout::is_index_iterator<ConstIterator>::value,
+			int
+		>::type compare_impl_1(const_iterator dest, size_type pos1, size_type n1, ConstIterator s, size_type n2) {
+			return compare_impl_2(
+				traits_type::compare(dest + pos1, s, NS_SSCRISK_CEL_OR_SPROUT::min(n1, n2)),
+				n1,
+				n2
+				);
+		}
+#endif
+		template<std::size_t M, sprout::index_t... Indexes>
+		static SPROUT_CONSTEXPR basic_string<T, sizeof...(Indexes), Traits> implicit_conversion_impl(
+			T const(& elems)[M],
+			size_type len,
+			sprout::index_tuple<Indexes...>
+			)
+		{
+			return sprout::basic_string<T, sizeof...(Indexes), Traits>{{(Indexes < M - 1 ? elems[Indexes] : T())...}, len};
+		}
+	public:
+		static SPROUT_CONSTEXPR basic_string<T, N, Traits> from_c_str(value_type const* s, size_type n) {
+			return !(N < n)
+				? from_c_str_impl(s, n, typename sprout::index_range<0, N>::type())
+				: throw std::out_of_range("basic_string<>: index out of range")
+				;
+		}
+		static SPROUT_CONSTEXPR basic_string<T, N, Traits> from_c_str(value_type const* s) {
+			return from_c_str(s, traits_type::length(s));
+		}
+	public:
+		value_type elems[static_size + 1];
+		size_type len;
+	public:
+		// construct/copy/destroy:
+		template<std::size_t N2>
+		basic_string<T, N, Traits>& operator=(basic_string<T, N2, Traits> const& rhs) {
+			return assign(rhs);
+		}
+		basic_string<T, N, Traits>& operator=(value_type const* rhs) {
+			return assign(rhs);
+		}
+		basic_string<T, N, Traits>& operator=(value_type rhs) {
+			return assign(1, rhs);
+		}
+		// iterators:
+#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
+		iterator begin() SPROUT_NOEXCEPT {
+			return iterator(*this, 0);
+		}
+		SPROUT_CONSTEXPR const_iterator begin() const SPROUT_NOEXCEPT {
+			return const_iterator(*this, 0);
+		}
+		iterator end() SPROUT_NOEXCEPT {
+			return iterator(*this, size());
+		}
+		SPROUT_CONSTEXPR const_iterator end() const SPROUT_NOEXCEPT {
+			return const_iterator(*this, size());
+		}
+#else
+		iterator begin() SPROUT_NOEXCEPT {
+			return &elems[0];
+		}
+		SPROUT_CONSTEXPR const_iterator begin() const SPROUT_NOEXCEPT {
+			return &elems[0];
+		}
+		iterator end() SPROUT_NOEXCEPT {
+			return &elems[0] + size();
+		}
+		SPROUT_CONSTEXPR const_iterator end() const SPROUT_NOEXCEPT {
+			return &elems[0] + size();
+		}
+#endif
+		reverse_iterator rbegin() SPROUT_NOEXCEPT {
+			return const_reverse_iterator(end());
+		}
+		SPROUT_CONSTEXPR const_reverse_iterator rbegin() const SPROUT_NOEXCEPT {
+			return const_reverse_iterator(end());
+		}
+		reverse_iterator rend() SPROUT_NOEXCEPT {
+			return const_reverse_iterator(begin());
+		}
+		SPROUT_CONSTEXPR const_reverse_iterator rend() const SPROUT_NOEXCEPT {
+			return const_reverse_iterator(begin());
+		}
+#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
+		SPROUT_CONSTEXPR const_iterator cbegin() const SPROUT_NOEXCEPT {
+			return const_iterator(*this, 0);
+		}
+		SPROUT_CONSTEXPR const_iterator cend() const SPROUT_NOEXCEPT {
+			return const_iterator(*this, size());
+		}
+#else
+		SPROUT_CONSTEXPR const_iterator cbegin() const SPROUT_NOEXCEPT {
+			return &elems[0];
+		}
+		SPROUT_CONSTEXPR const_iterator cend() const SPROUT_NOEXCEPT {
+			return &elems[0] + size();
+		}
+#endif
+		SPROUT_CONSTEXPR const_reverse_iterator crbegin() const SPROUT_NOEXCEPT {
+			return const_reverse_iterator(end());
+		}
+		SPROUT_CONSTEXPR const_reverse_iterator crend() const SPROUT_NOEXCEPT {
+			return const_reverse_iterator(begin());
+		}
+		// capacity:
+		SPROUT_CONSTEXPR size_type size() const SPROUT_NOEXCEPT {
+			return len;
+		}
+		SPROUT_CONSTEXPR size_type length() const SPROUT_NOEXCEPT {
+			return size();
+		}
+		SPROUT_CONSTEXPR size_type max_size() const SPROUT_NOEXCEPT {
+			return static_size;
+		}
+		void resize(size_type n, value_type c) {
+			maxcheck(n);
+			if (n > size()) {
+				traits_type::assign(end(), n - size(), c);
+			}
+			traits_type::assign(begin() + n, max_size() - n, value_type());
+			len = n;
+		}
+		void resize(size_type n) {
+			resize(n, value_type());
+		}
+		void clear() {
+			traits_type::assign(begin(), max_size(), value_type());
+			len = 0;
+		}
+		SPROUT_CONSTEXPR bool empty() const SPROUT_NOEXCEPT {
+			return size() == 0;
+		}
+		// element access:
+		reference operator[](size_type i) {
+			return elems[i];
+		}
+		SPROUT_CONSTEXPR const_reference operator[](size_type i) const {
+			return elems[i];
+		}
+		reference at(size_type i) {
+			return i < size()
+				? elems[i]
+				: (throw std::out_of_range("basic_string<>: index out of range"), elems[i])
+				;
+		}
+		SPROUT_CONSTEXPR const_reference at(size_type i) const {
+			return i < size()
+				? elems[i]
+				: (throw std::out_of_range("basic_string<>: index out of range"), elems[i])
+				;
+		}
+		reference front() {
+			return elems[0];
+		}
+		SPROUT_CONSTEXPR const_reference front() const {
+			return elems[0];
+		}
+		reference back() {
+			return elems[size() - 1];
+		}
+		SPROUT_CONSTEXPR const_reference back() const {
+			return elems[size() - 1];
+		}
+		// modifiers:
+		template<std::size_t N2>
+		basic_string<T, N, Traits>& assign(basic_string<T, N2, Traits> const& str) {
+			return assign(str.begin(), str.size());
+		}
+		template<std::size_t N2>
+		basic_string<T, N, Traits>& assign(basic_string<T, N2, Traits> const& str, size_type pos, size_type n) {
+			if (str.size() < pos + n) {
+				throw std::out_of_range("basic_string<>: index out of range");
+			}
+			return assign(str.begin() + pos, n);
+		}
+		basic_string<T, N, Traits>& assign(value_type const* s, size_type n) {
+			maxcheck(n);
+			for (size_type i = 0; i < n; ++i) {
+				traits_type::assign(elems[i], s[i]);
+			}
+			for (size_type i = n; i < max_size(); ++i) {
+				traits_type::assign(elems[i], value_type());
+			}
+			len = n;
+			return *this;
+		}
+		basic_string<T, N, Traits>& assign(value_type const* s) {
+			return assign(s, traits_type::length(s));
+		}
+		basic_string<T, N, Traits>& assign(size_type n, value_type c) {
+			maxcheck(n);
+			traits_type::assign(begin(), n, c);
+			traits_type::assign(begin() + n, max_size() - n, value_type());
+			len = n;
+			return *this;
+		}
+		template<typename Iterator>
+		basic_string<T, N, Traits>& assign(Iterator first, Iterator last) {
+			size_type n = 0;
+			for (; n < max_size() || first != last; ++n, ++first) {
+				traits_type::assign(elems[n], *first);
+			}
+			for (size_type i = n; i < max_size(); ++i) {
+				traits_type::assign(elems[i], value_type());
+			}
+			len = n;
+			return *this;
+		}
+		void swap(basic_string<T, N, Traits>& other) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(std::swap(std::declval<T&>(), std::declval<T&>()))) {
+			std::swap_ranges(other.begin(), other.begin() + other.max_size(), begin());
+			{
+				using std::swap;
+				swap(len, other.len);
+			}
+		}
+		// string operations:
+		SPROUT_CONSTEXPR const_pointer c_str() const SPROUT_NOEXCEPT {
+			return &elems[0];
+		}
+		pointer data() SPROUT_NOEXCEPT {
+			return &elems[0];
+		}
+		SPROUT_CONSTEXPR const_pointer data() const SPROUT_NOEXCEPT {
+			return &elems[0];
+		}
+		SPROUT_CONSTEXPR basic_string<T, N, Traits> substr(size_type pos = 0, size_type n = npos) const {
+			return !(size() < pos)
+				? n == npos
+					? substr(pos, size() - pos)
+					: from_c_str(c_str() + pos, n)
+				: throw std::out_of_range("basic_string<>: index out of range")
+				;
+		}
+		template<std::size_t N2>
+		SPROUT_CONSTEXPR int compare(basic_string<T, N2, Traits> const& str) const {
+			return compare(0, size(), str.begin(), str.size());
+		}
+		SPROUT_CONSTEXPR int compare(value_type const* s) const {
+			return compare(0, size(), s, traits_type::length(s));
+		}
+		template<std::size_t N2>
+		SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, basic_string<T, N2, Traits> const& str) const {
+			return compare(pos1, n1, str, 0, npos);
+		}
+		SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, value_type const* s) const {
+			return compare(pos1, n1, s, traits_type::length(s));
+		}
+		template<std::size_t N2>
+		SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, basic_string<T, N2, Traits> const& str, size_type pos2, size_type n2) const {
+			return !(str.size() < pos2)
+				? compare(pos1, n1, str.begin() + pos2, NS_SSCRISK_CEL_OR_SPROUT::min(n2, str.size() - pos2))
+				: throw std::out_of_range("basic_string<>: index out of range")
+				;
+		}
+		SPROUT_CONSTEXPR int compare(size_type pos1, size_type n1, value_type const* s, size_type n2) const {
+			return !(size() < pos1)
+				? compare_impl_1(begin(), pos1, NS_SSCRISK_CEL_OR_SPROUT::min(n1, size() - pos1), s, n2)
+				: throw std::out_of_range("basic_string<>: index out of range")
+				;
+		}
+		// others:
+		template<std::size_t N2, typename Enable = typename std::enable_if<(N2 > N)>::type>
+		SPROUT_CONSTEXPR operator basic_string<T, N2, Traits>() const {
+			return implicit_conversion_impl(
+				elems,
+				len,
+				typename sprout::index_range<0, N2>::type()
+				);
+		}
+		pointer c_array() SPROUT_NOEXCEPT {
+			return &elems[0];
+		}
+		void rangecheck(size_type i) const {
+			if (i >= size()) {
+				throw std::out_of_range("basic_string<>: index out of range");
+			}
+		}
+		void maxcheck(size_type n) const {
+			if (n > max_size()) {
+				throw std::out_of_range("basic_string<>: index out of range");
+			}
+		}
+#if SPROUT_USE_INDEX_ITERATOR_IMPLEMENTATION
+		template<typename ConstIterator>
+		typename std::enable_if<
+			sprout::is_index_iterator<ConstIterator>::value,
+			basic_string<T, N, Traits>&
+		>::type assign(ConstIterator s, size_type n) {
+			maxcheck(n);
+			for (size_type i = 0; i < n; ++i) {
+				traits_type::assign(elems[i], s[i]);
+			}
+			for (size_type i = n; i < max_size(); ++i) {
+				traits_type::assign(elems[i], value_type());
+			}
+			len = n;
+			return *this;
+		}
+		template<typename ConstIterator>
+		typename std::enable_if<
+			sprout::is_index_iterator<ConstIterator>::value,
+			basic_string<T, N, Traits>&
+		>::type assign(ConstIterator s) {
+			return assign(s, traits_type::length(s));
+		}
+		template<typename ConstIterator>
+		typename std::enable_if<
+			sprout::is_index_iterator<ConstIterator>::value,
+			basic_string<T, N, Traits>&
+		>::type operator=(ConstIterator rhs) {
+			return assign(rhs);
+		}
+		template<typename ConstIterator>
+		SPROUT_CONSTEXPR typename std::enable_if<
+			sprout::is_index_iterator<ConstIterator>::value,
+			int
+		>::type compare(ConstIterator s) const {
+			return compare(0, size(), s, traits_type::length(s));
+		}
+		template<typename ConstIterator>
+		SPROUT_CONSTEXPR typename std::enable_if<
+			sprout::is_index_iterator<ConstIterator>::value,
+			int
+		>::type compare(size_type pos1, size_type n1, ConstIterator s) const {
+			return compare(pos1, n1, s, traits_type::length(s));
+		}
+		template<typename ConstIterator>
+		SPROUT_CONSTEXPR typename std::enable_if<
+			sprout::is_index_iterator<ConstIterator>::value,
+			int
+		>::type compare(size_type pos1, size_type n1, ConstIterator s, size_type n2) const {
+			return !(size() < pos1)
+				? compare_impl_1(begin(), pos1, NS_SSCRISK_CEL_OR_SPROUT::min(n1, size() - pos1), s, n2)
+				: throw std::out_of_range("basic_string<>: index out of range")
+				;
+		}
+#endif
+	};
+	template<typename T, std::size_t N, typename Traits>
+	SPROUT_CONSTEXPR typename sprout::basic_string<T, N, Traits>::size_type sprout::basic_string<T, N, Traits>::npos;
+	template<typename T, std::size_t N, typename Traits>
+	SPROUT_CONSTEXPR typename sprout::basic_string<T, N, Traits>::size_type sprout::basic_string<T, N, Traits>::static_size;
+
+	//
+	// swap
+	//
+	template<typename T, std::size_t N, typename Traits>
+	inline void swap(
+		sprout::basic_string<T, N, Traits>& lhs,
+		sprout::basic_string<T, N, Traits>& rhs
+		) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
+	{
+		lhs.swap(rhs);
+	}
+
+	namespace detail {
+		template<typename Container>
+		struct make_construct_impl;
+
+		template<typename T, std::size_t N, typename Traits>
+		struct make_construct_impl<sprout::basic_string<T, N, Traits> > {
+		private:
+			typedef sprout::basic_string<T, N, Traits> copied_type;
+		private:
+			template<std::size_t S>
+			static SPROUT_CONSTEXPR copied_type make_impl(typename copied_type::size_type size) {
+				return copied_type{{}, size};
+			}
+			template<std::size_t S, typename Head, typename... Tail>
+			static SPROUT_CONSTEXPR typename std::enable_if<
+				S == sizeof...(Tail),
+				copied_type
+			>::type make_impl(typename copied_type::size_type size, Head&& head, Tail&&... tail) {
+				return copied_type{{sprout::forward<Tail>(tail)..., sprout::forward<Head>(head)}, size};
+			}
+			template<std::size_t S, typename Head, typename... Tail>
+			static SPROUT_CONSTEXPR typename std::enable_if<
+				S != sizeof...(Tail),
+				copied_type
+			>::type make_impl(typename copied_type::size_type size, Head&& head, Tail&&... tail) {
+				return make_impl<S + 1>(size, sprout::forward<Tail>(tail)..., S >= size ? T() : sprout::forward<Head>(head));
+			}
+		public:
+			static SPROUT_CONSTEXPR typename copied_type::size_type length() {
+				return 0;
+			}
+			template<typename... Tail>
+			static SPROUT_CONSTEXPR typename copied_type::size_type length(T const& head, Tail&&... tail) {
+				return !head ? 0 : 1 + length(sprout::forward<Tail>(tail)...);
+			}
+			template<typename... Args>
+			static SPROUT_CONSTEXPR copied_type make(typename copied_type::size_type size, Args&&... args) {
+				return make_impl<0>(size, sprout::forward<Args>(args)...);
+			}
+		};
+	}	// namespace detail
+
+	//
+	// to_string
+	//
+	namespace detail {
+		template<typename T, std::size_t N, sprout::index_t... Indexes>
+		inline SPROUT_CONSTEXPR sprout::basic_string<T, N - 1> to_string_impl_1(
+			T const(& arr)[N],
+			typename sprout::basic_string<T, N - 1>::size_type n,
+			sprout::index_tuple<Indexes...>
+			)
+		{
+			return sprout::basic_string<T, N - 1>{{(Indexes < n ? arr[Indexes] : T())...}, n};
+		}
+		template<typename T, std::size_t N, sprout::index_t... Indexes>
+		inline SPROUT_CONSTEXPR sprout::basic_string<T, N - 1> to_string_impl(
+			T const(& arr)[N],
+			sprout::index_tuple<Indexes...>
+			)
+		{
+			return to_string_impl_1(arr, sprout::char_traits<T>::length(arr), sprout::index_tuple<Indexes...>());
+		}
+	}	// namespace detail
+	template<typename T, std::size_t N>
+	inline SPROUT_CONSTEXPR sprout::basic_string<T, N - 1> to_string(T const(& arr)[N]) {
+		return sprout::detail::to_string_impl(arr, typename sprout::index_range<0, N - 1>::type());
+	}
+
+	//
+	// string_from_c_str
+	//
+	template<std::size_t N, typename T>
+	inline SPROUT_CONSTEXPR sprout::basic_string<T, N> string_from_c_str(T const* s, std::size_t n) {
+		return sprout::basic_string<T, N>::from_c_str(s, n);
+	}
+	template<std::size_t N, typename T>
+	inline SPROUT_CONSTEXPR sprout::basic_string<T, N> string_from_c_str(T const* s) {
+		return sprout::basic_string<T, N>::from_c_str(s);
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_STRING_STRING_HPP
diff --git a/sprout/string/to_string.hpp b/sprout/string/to_string.hpp
new file mode 100644
index 00000000..61cdace5
--- /dev/null
+++ b/sprout/string/to_string.hpp
@@ -0,0 +1,296 @@
+#ifndef SPROUT_STRING_TO_STRING_HPP
+#define SPROUT_STRING_TO_STRING_HPP
+
+#include <cstddef>
+#include <stdexcept>
+#include <type_traits>
+#include <sprout/string/string.hpp>
+#include <sprout/string/make_string.hpp>
+#include <sprout/integer/integer_digits.hpp>
+#include <sprout/utility/enabler_if.hpp>
+
+namespace sprout {
+	namespace detail {
+		template<
+			typename Elem,
+			std::size_t Base,
+			typename IntType,
+			typename sprout::enabler_if<(Base < 10)>::type = sprout::enabler
+		>
+		inline SPROUT_CONSTEXPR Elem int_to_char(IntType val){
+			return val >= 0 && val < 10 ? static_cast<Elem>('0') + val
+				: throw std::invalid_argument("value out of bounds")
+				;
+		}
+		template<
+			typename Elem,
+			std::size_t Base,
+			typename IntType,
+			typename sprout::enabler_if<(Base >= 10 && Base < 36)>::type = sprout::enabler
+		>
+		inline SPROUT_CONSTEXPR Elem int_to_char(IntType val){
+			return val >= 0 && val < 10 ? static_cast<Elem>('0') + val
+				: val >= 10 && val < 36 ? static_cast<Elem>('a') + (val - 10)
+				: throw std::invalid_argument("value out of bounds")
+				;
+		}
+
+		template<
+			typename Elem,
+			std::size_t Base,
+			typename IntType,
+			typename... Args,
+			typename sprout::enabler_if<(sizeof...(Args) == sprout::integer_digits<IntType, Base>::value - 1)>::type = sprout::enabler
+		>
+		inline SPROUT_CONSTEXPR sprout::basic_string<Elem, sprout::integer_digits<IntType, Base>::value>
+		int_to_string_impl_1(IntType val, bool negative, Args... args) {
+			return negative ? sprout::make_string_as<Elem>(static_cast<Elem>('-'), args...)
+				: sprout::make_string_as<Elem>(args...)
+				;
+		}
+		template<
+			typename Elem,
+			std::size_t Base,
+			typename IntType,
+			typename... Args,
+			typename sprout::enabler_if<(sizeof...(Args) < sprout::integer_digits<IntType, Base>::value - 1)>::type = sprout::enabler
+		>
+		inline SPROUT_CONSTEXPR sprout::basic_string<Elem, sprout::integer_digits<IntType, Base>::value>
+		int_to_string_impl_1(IntType val, bool negative, Args... args) {
+			return val == 0
+				? (negative ? sprout::make_string_as<Elem>(static_cast<Elem>('-'), args...)
+					: sprout::make_string_as<Elem>(args...)
+					)
+				: sprout::detail::int_to_string_impl_1<Elem, Base>(
+					val / Base,
+					negative,
+					sprout::detail::int_to_char<Elem, Base>(val % Base),
+					args...
+					)
+				;
+		}
+		template<typename Elem, std::size_t Base, typename IntType>
+		inline SPROUT_CONSTEXPR sprout::basic_string<Elem, sprout::integer_digits<IntType, Base>::value>
+		int_to_string_impl(IntType val) {
+			return val == 0 ? sprout::make_string_as<Elem>(static_cast<Elem>('0'))
+				: val < 0 ? sprout::detail::int_to_string_impl_1<Elem, Base>(-val, true)
+				: sprout::detail::int_to_string_impl_1<Elem, Base>(val, false)
+				;
+		}
+
+		template<
+			typename Elem,
+			std::size_t Base,
+			typename UIntType,
+			typename... Args,
+			typename sprout::enabler_if<(sizeof...(Args) == sprout::integer_digits<UIntType, Base>::value)>::type = sprout::enabler
+		>
+		inline SPROUT_CONSTEXPR sprout::basic_string<Elem, sprout::integer_digits<UIntType, Base>::value>
+		uint_to_string_impl_1(UIntType val, Args... args) {
+			return sprout::make_string_as<Elem>(args...);
+		}
+		template<
+			typename Elem,
+			std::size_t Base,
+			typename UIntType,
+			typename... Args,
+			typename sprout::enabler_if<(sizeof...(Args) < sprout::integer_digits<UIntType, Base>::value)>::type = sprout::enabler
+		>
+		inline SPROUT_CONSTEXPR sprout::basic_string<Elem, sprout::integer_digits<UIntType, Base>::value>
+		uint_to_string_impl_1(UIntType val, Args... args) {
+			return val == 0
+				? sprout::make_string_as<Elem>(args...)
+				: sprout::detail::uint_to_string_impl_1<Elem, Base>(
+					val / Base,
+					sprout::detail::int_to_char<Elem, Base>(val % Base),
+					args...
+					)
+				;
+		}
+		template<typename Elem, std::size_t Base, typename UIntType>
+		inline SPROUT_CONSTEXPR sprout::basic_string<Elem, sprout::integer_digits<UIntType, Base>::value>
+		uint_to_string_impl(UIntType val) {
+			return val == 0 ? sprout::make_string_as<Elem>(static_cast<Elem>('0'))
+				: sprout::detail::uint_to_string_impl_1<Elem, Base>(val)
+				;
+		}
+
+		template<
+			typename Elem,
+			std::size_t Base,
+			typename IntType,
+			typename sprout::enabler_if<std::is_signed<IntType>::value>::type = sprout::enabler
+		>
+		inline SPROUT_CONSTEXPR sprout::basic_string<Elem, sprout::integer_digits<IntType, Base>::value>
+		int_to_string(IntType val) {
+			return sprout::detail::int_to_string_impl<Elem, Base>(val);
+		}
+		template<
+			typename Elem,
+			std::size_t Base,
+			typename IntType,
+			typename sprout::enabler_if<std::is_unsigned<IntType>::value>::type = sprout::enabler
+		>
+		inline SPROUT_CONSTEXPR sprout::basic_string<Elem, sprout::integer_digits<IntType, Base>::value>
+		int_to_string(IntType val) {
+			return sprout::detail::uint_to_string_impl<Elem, Base>(val);
+		}
+	}	// namespace detail
+
+	//
+	// int_to_string
+	//
+	template<
+		typename Elem,
+		std::size_t Base,
+		typename IntType,
+		typename sprout::enabler_if<std::is_integral<IntType>::value>::type = sprout::enabler
+	>
+	inline SPROUT_CONSTEXPR sprout::basic_string<Elem, sprout::integer_digits<IntType, Base>::value>
+	int_to_string(IntType val) {
+		return sprout::detail::int_to_string<Elem, Base>(val);
+	}
+
+	//
+	// to_string_of
+	//
+	template<typename Elem, typename IntType, typename sprout::enabler_if<std::is_integral<IntType>::value>::type = sprout::enabler>
+	inline SPROUT_CONSTEXPR sprout::basic_string<Elem, sprout::integer_digits<IntType, 10>::value>
+	to_string_of(IntType val) {
+		return sprout::int_to_string<Elem, 10>(val);
+	}
+
+	//
+	// to_string
+	//
+	inline SPROUT_CONSTEXPR sprout::basic_string<char, sprout::integer_digits<int>::value>
+	to_string(int val) {
+		return sprout::to_string_of<char>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char, sprout::integer_digits<unsigned>::value>
+	to_string(unsigned val) {
+		return sprout::to_string_of<char>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char, sprout::integer_digits<long>::value>
+	to_string(long val) {
+		return sprout::to_string_of<char>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char, sprout::integer_digits<unsigned long>::value>
+	to_string(unsigned long val) {
+		return sprout::to_string_of<char>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char, sprout::integer_digits<long long>::value>
+	to_string(long long val) {
+		return sprout::to_string_of<char>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char, sprout::integer_digits<unsigned long long>::value>
+	to_string(unsigned long long val) {
+		return sprout::to_string_of<char>(val);
+	}
+	template<typename IntType, typename sprout::enabler_if<std::is_integral<IntType>::value>::type = sprout::enabler>
+	inline SPROUT_CONSTEXPR sprout::basic_string<char, sprout::integer_digits<IntType>::value>
+	to_string(IntType val) {
+		return sprout::to_string_of<char>(val);
+	}
+
+	//
+	// to_wstring
+	//
+	inline SPROUT_CONSTEXPR sprout::basic_string<wchar_t, sprout::integer_digits<int>::value>
+	to_wstring(int val) {
+		return sprout::to_string_of<wchar_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<wchar_t, sprout::integer_digits<unsigned>::value>
+	to_wstring(unsigned val) {
+		return sprout::to_string_of<wchar_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<wchar_t, sprout::integer_digits<long>::value>
+	to_wstring(long val) {
+		return sprout::to_string_of<wchar_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<wchar_t, sprout::integer_digits<unsigned long>::value>
+	to_wstring(unsigned long val) {
+		return sprout::to_string_of<wchar_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<wchar_t, sprout::integer_digits<long long>::value>
+	to_wstring(long long val) {
+		return sprout::to_string_of<wchar_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<wchar_t, sprout::integer_digits<unsigned long long>::value>
+	to_wstring(unsigned long long val) {
+		return sprout::to_string_of<wchar_t>(val);
+	}
+	template<typename IntType, typename sprout::enabler_if<std::is_integral<IntType>::value>::type = sprout::enabler>
+	inline SPROUT_CONSTEXPR sprout::basic_string<wchar_t, sprout::integer_digits<IntType>::value>
+	to_wstring(IntType val) {
+		return sprout::to_string_of<wchar_t>(val);
+	}
+
+	//
+	// to_u16string
+	//
+	inline SPROUT_CONSTEXPR sprout::basic_string<char16_t, sprout::integer_digits<int>::value>
+	to_u16string(int val) {
+		return sprout::to_string_of<char16_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char16_t, sprout::integer_digits<unsigned>::value>
+	to_u16string(unsigned val) {
+		return sprout::to_string_of<char16_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char16_t, sprout::integer_digits<long>::value>
+	to_u16string(long val) {
+		return sprout::to_string_of<char16_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char16_t, sprout::integer_digits<unsigned long>::value>
+	to_u16string(unsigned long val) {
+		return sprout::to_string_of<char16_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char16_t, sprout::integer_digits<long long>::value>
+	to_u16string(long long val) {
+		return sprout::to_string_of<char16_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char16_t, sprout::integer_digits<unsigned long long>::value>
+	to_u16string(unsigned long long val) {
+		return sprout::to_string_of<char16_t>(val);
+	}
+	template<typename IntType, typename sprout::enabler_if<std::is_integral<IntType>::value>::type = sprout::enabler>
+	inline SPROUT_CONSTEXPR sprout::basic_string<char16_t, sprout::integer_digits<IntType>::value>
+	to_u16string(IntType val) {
+		return sprout::to_string_of<char16_t>(val);
+	}
+
+	//
+	// to_u32string
+	//
+	inline SPROUT_CONSTEXPR sprout::basic_string<char32_t, sprout::integer_digits<int>::value>
+	to_u32string(int val) {
+		return sprout::to_string_of<char32_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char32_t, sprout::integer_digits<unsigned>::value>
+	to_u32string(unsigned val) {
+		return sprout::to_string_of<char32_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char32_t, sprout::integer_digits<long>::value>
+	to_u32string(long val) {
+		return sprout::to_string_of<char32_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char32_t, sprout::integer_digits<unsigned long>::value>
+	to_u32string(unsigned long val) {
+		return sprout::to_string_of<char32_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char32_t, sprout::integer_digits<long long>::value>
+	to_u32string(long long val) {
+		return sprout::to_string_of<char32_t>(val);
+	}
+	inline SPROUT_CONSTEXPR sprout::basic_string<char32_t, sprout::integer_digits<unsigned long long>::value>
+	to_u32string(unsigned long long val) {
+		return sprout::to_string_of<char32_t>(val);
+	}
+	template<typename IntType, typename sprout::enabler_if<std::is_integral<IntType>::value>::type = sprout::enabler>
+	inline SPROUT_CONSTEXPR sprout::basic_string<char32_t, sprout::integer_digits<IntType>::value>
+	to_u32string(IntType val) {
+		return sprout::to_string_of<char32_t>(val);
+	}
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_STRING_TO_STRING_HPP
diff --git a/sprout/string/tuple.hpp b/sprout/string/tuple.hpp
new file mode 100644
index 00000000..e139f671
--- /dev/null
+++ b/sprout/string/tuple.hpp
@@ -0,0 +1,29 @@
+#ifndef SPROUT_STRING_TUPLE_HPP
+#define SPROUT_STRING_TUPLE_HPP
+
+#include <cstddef>
+#include <tuple>
+#include <type_traits>
+#include <sprout/string/string.hpp>
+
+namespace std {
+	//
+	// tuple_size
+	//
+	template<typename T, std::size_t N, typename Traits>
+	struct tuple_size<sprout::basic_string<T, N, Traits> >
+		: public std::integral_constant<std::size_t, N>
+	{};
+
+	//
+	// tuple_element
+	//
+	template<std::size_t I, typename T, std::size_t N, typename Traits>
+	struct tuple_element<I, sprout::basic_string<T, N, Traits> > {
+	public:
+		static_assert(I < N, "tuple_element<>: index out of range");
+		typedef T type;
+	};
+}	// namespace std
+
+#endif	// #ifndef SPROUT_STRING_TUPLE_HPP
diff --git a/sprout/string/type_traits.hpp b/sprout/string/type_traits.hpp
new file mode 100644
index 00000000..599d3888
--- /dev/null
+++ b/sprout/string/type_traits.hpp
@@ -0,0 +1,113 @@
+#ifndef SPROUT_STRING_TYPE_TRAITS_HPP
+#define SPROUT_STRING_TYPE_TRAITS_HPP
+
+#include <cstddef>
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/string/string.hpp>
+
+namespace sprout {
+	//
+	// string_t
+	//
+	template<std::size_t N>
+	struct string_t {
+	public:
+		typedef sprout::basic_string<char, N> type;
+	};
+	//
+	// wstring_t
+	//
+	template<std::size_t N>
+	struct wstring_t {
+	public:
+		typedef sprout::basic_string<wchar_t, N> type;
+	};
+	//
+	// u16string_t
+	//
+	template<std::size_t N>
+	struct u16string_t {
+	public:
+		typedef sprout::basic_string<char16_t, N> type;
+	};
+	//
+	// u32string_t
+	//
+	template<std::size_t N>
+	struct u32string_t {
+	public:
+		typedef sprout::basic_string<char32_t, N> type;
+	};
+
+	//
+	// is_basic_string
+	//
+	template<typename T>
+	struct is_basic_string
+		: public std::false_type
+	{};
+	template<typename T>
+	struct is_basic_string<T const>
+		: public sprout::is_basic_string<T>
+	{};
+	template<typename T>
+	struct is_basic_string<T const volatile>
+		: public sprout::is_basic_string<T>
+	{};
+	template<typename T, std::size_t N, typename Traits>
+	struct is_basic_string<sprout::basic_string<T, N, Traits> >
+		: public std::true_type
+	{};
+
+	//
+	// is_string_of
+	//
+	template<typename T, typename Elem>
+	struct is_string_of
+		: public std::false_type
+	{};
+	template<typename T, typename Elem>
+	struct is_string_of<T const, Elem>
+		: public sprout::is_string_of<T, Elem>
+	{};
+	template<typename T, typename Elem>
+	struct is_string_of<T const volatile, Elem>
+		: public sprout::is_string_of<T, Elem>
+	{};
+	template<typename T, std::size_t N, typename Traits, typename Elem>
+	struct is_string_of<sprout::basic_string<T, N, Traits>, Elem>
+		: public std::true_type
+	{};
+
+	//
+	// is_string
+	//
+	template<typename T>
+	struct is_string
+		: public sprout::is_string_of<T, char>
+	{};
+	//
+	// is_wstring
+	//
+	template<typename T>
+	struct is_wstring
+		: public sprout::is_string_of<T, wchar_t>
+	{};
+	//
+	// is_u16string
+	//
+	template<typename T>
+	struct is_u16string
+		: public sprout::is_string_of<T, char16_t>
+	{};
+	//
+	// is_u32string
+	//
+	template<typename T>
+	struct is_u32string
+		: public sprout::is_string_of<T, char32_t>
+	{};
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_STRING_TYPE_TRAITS_HPP