From 2d039ad6b4b4cb280b97e0a3c901f0d589f9d4a2 Mon Sep 17 00:00:00 2001
From: bolero-MURAKAMI <bolero.murakami@gmail.com>
Date: Sun, 15 Jul 2012 21:20:56 +0900
Subject: [PATCH] add tuple_cat

---
 sprout/tuple/sub_array.hpp                    |  45 --
 sprout/tuple/traits.hpp                       |   1 +
 sprout/tuple/tuple.hpp                        | 552 +-----------------
 .../comparison.hpp}                           |   3 +-
 sprout/tuple/tuple/get.hpp                    | 102 ++++
 sprout/tuple/tuple/ignore.hpp                 |  28 +
 sprout/tuple/tuple/make_tuple.hpp             | 163 ++++++
 sprout/tuple/tuple/tuple.hpp                  | 397 +++++++++++++
 sprout/tuple/tuple/tuple_fwd.hpp              |  13 +
 sprout/tuple/tuple/type_traits.hpp            |  34 ++
 sprout/type/string.hpp                        |  37 +-
 sprout/type/string/alias.hpp                  |   2 +-
 sprout/type/string/string.hpp                 |  40 ++
 sprout/type/string/to_string.hpp              |   2 +-
 sprout/type/string/to_string_constant.hpp     |   2 +-
 sprout/uuid.hpp                               |   8 +-
 .../{uuid_generators.hpp => generators.hpp}   |   6 +-
 sprout/uuid/{uuid_hash.hpp => hash.hpp}       |   6 +-
 sprout/uuid/{uuid_io.hpp => io.hpp}           |   6 +-
 sprout/uuid/{uuid_tuple.hpp => tuple.hpp}     |   6 +-
 20 files changed, 807 insertions(+), 646 deletions(-)
 delete mode 100644 sprout/tuple/sub_array.hpp
 rename sprout/tuple/{tuple_comparison.hpp => tuple/comparison.hpp} (94%)
 create mode 100644 sprout/tuple/tuple/get.hpp
 create mode 100644 sprout/tuple/tuple/ignore.hpp
 create mode 100644 sprout/tuple/tuple/make_tuple.hpp
 create mode 100644 sprout/tuple/tuple/tuple.hpp
 create mode 100644 sprout/tuple/tuple/tuple_fwd.hpp
 create mode 100644 sprout/tuple/tuple/type_traits.hpp
 create mode 100644 sprout/type/string/string.hpp
 rename sprout/uuid/{uuid_generators.hpp => generators.hpp} (59%)
 rename sprout/uuid/{uuid_hash.hpp => hash.hpp} (70%)
 rename sprout/uuid/{uuid_io.hpp => io.hpp} (95%)
 rename sprout/uuid/{uuid_tuple.hpp => tuple.hpp} (88%)

diff --git a/sprout/tuple/sub_array.hpp b/sprout/tuple/sub_array.hpp
deleted file mode 100644
index e6ddf407..00000000
--- a/sprout/tuple/sub_array.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef SPROUT_TUPLE_SUB_ARRAY_HPP
-#define SPROUT_TUPLE_SUB_ARRAY_HPP
-
-#include <cstddef>
-#include <type_traits>
-#include <sprout/config.hpp>
-#include <sprout/container/functions.hpp>
-#include <sprout/iterator/operation.hpp>
-#include <sprout/utility/move.hpp>
-#include <sprout/sub_array.hpp>
-
-namespace sprout {
-	namespace tuples {
-		//
-		// get
-		//
-		template<std::size_t I, typename Container>
-		inline SPROUT_CONSTEXPR typename sprout::container_traits<sprout::sub_array<Container> >::value_type&
-		get(sprout::sub_array<Container>& t)
-			SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(*sprout::next(sprout::internal_begin(t), I)))
-		{
-			static_assert(I < sprout::container_traits<sprout::sub_array<Container> >::static_size, "get: index out of range");
-			return *sprout::next(sprout::internal_begin(t), I);
-		}
-		template<std::size_t I, typename Container>
-		inline SPROUT_CONSTEXPR typename sprout::container_traits<sprout::sub_array<Container> >::value_type const&
-		get(sprout::sub_array<Container> const& t)
-			SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(*sprout::next(sprout::internal_begin(t), I)))
-		{
-			static_assert(I < sprout::container_traits<sprout::sub_array<Container> >::static_size, "get: index out of range");
-			return *sprout::next(sprout::internal_begin(t), I);
-		}
-		template<std::size_t I, typename Container>
-		inline SPROUT_CONSTEXPR typename sprout::container_traits<sprout::sub_array<Container> >::value_type&&
-		get(sprout::sub_array<Container>&& t)
-			SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(sprout::move(sprout::tuples::get<I>(t))))
-		{
-			return sprout::move(sprout::tuples::get<I>(t));
-		}
-	}	// namespace tuples
-
-	using sprout::tuples::get;
-}	// namespace sprout
-
-#endif	// #ifndef SPROUT_TUPLE_SUB_ARRAY_HPP
diff --git a/sprout/tuple/traits.hpp b/sprout/tuple/traits.hpp
index 49c11b58..7861e1d4 100644
--- a/sprout/tuple/traits.hpp
+++ b/sprout/tuple/traits.hpp
@@ -5,6 +5,7 @@
 #include <sprout/index_tuple.hpp>
 #include <sprout/tuple/tuple.hpp>
 #include <sprout/type/rebind_types.hpp>
+#include <sprout/utility/forward.hpp>
 
 namespace sprout {
 	namespace types {
diff --git a/sprout/tuple/tuple.hpp b/sprout/tuple/tuple.hpp
index abd15dc0..101edf4f 100644
--- a/sprout/tuple/tuple.hpp
+++ b/sprout/tuple/tuple.hpp
@@ -1,551 +1,13 @@
 #ifndef SPROUT_TUPLE_TUPLE_HPP
 #define SPROUT_TUPLE_TUPLE_HPP
 
-#include <cstddef>
-#include <utility>
-#include <type_traits>
-#include <tuple>
 #include <sprout/config.hpp>
-#include <sprout/utility/operation.hpp>
-
-namespace sprout {
-	namespace tuples {
-		namespace detail {
-			template<std::size_t Index, typename Head, bool IsEmpty>
-			class head_base;
-			//!!!
-			// EBO disabled
-//			template<std::size_t Index, typename Head>
-//			class head_base<Index, Head, true>
-//				: public Head
-//			{
-//			public:
-//				static SPROUT_CONSTEXPR Head& head(head_base& t) SPROUT_NOEXCEPT {
-//					return t;
-//				}
-//				static SPROUT_CONSTEXPR Head const& head(head_base const& t) SPROUT_NOEXCEPT {
-//					return t;
-//				}
-//			public:
-//				SPROUT_CONSTEXPR head_base()
-//					: Head()
-//				{}
-//				SPROUT_CONSTEXPR head_base(Head const& v)
-//					: Head(v)
-//				{}
-//				template<typename UHead>
-//				SPROUT_CONSTEXPR head_base(UHead&& v)
-//					: Head(sprout::forward<UHead>(v))
-//				{}
-//			};
-			template<std::size_t Index, typename Head>
-			class head_base<Index, Head, true> {
-			public:
-				static SPROUT_CONSTEXPR Head& head(head_base& t) SPROUT_NOEXCEPT {
-					return t.head_;
-				}
-				static SPROUT_CONSTEXPR Head const& head(head_base const& t) SPROUT_NOEXCEPT {
-					return t.head_;
-				}
-			private:
-				Head head_;
-			public:
-				SPROUT_CONSTEXPR head_base()
-					: head_()
-				{}
-				SPROUT_CONSTEXPR head_base(Head const& v)
-					: head_(v)
-				{}
-				template<typename UHead>
-				SPROUT_CONSTEXPR head_base(UHead&& v)
-					: head_(sprout::forward<UHead>(v))
-				{}
-			};
-			template<std::size_t Index, typename Head>
-			class head_base<Index, Head, false> {
-			public:
-				static SPROUT_CONSTEXPR Head& head(head_base& t) SPROUT_NOEXCEPT {
-					return t.head_;
-				}
-				static SPROUT_CONSTEXPR Head const& head(head_base const& t) SPROUT_NOEXCEPT {
-					return t.head_;
-				}
-			private:
-				Head head_;
-			public:
-				SPROUT_CONSTEXPR head_base()
-					: head_()
-				{}
-				SPROUT_CONSTEXPR head_base(Head const& v)
-					: head_(v)
-				{}
-				template<typename UHead>
-				SPROUT_CONSTEXPR head_base(UHead&& v)
-					: head_(sprout::forward<UHead>(v))
-				{}
-			};
-
-			template<std::size_t Index, typename... Types>
-			class tuple_impl;
-			template<std::size_t Index>
-			class tuple_impl<Index> {
-			public:
-				template<std::size_t, typename...>
-				friend class sprout::tuples::detail::tuple_impl;
-			protected:
-				void swap(tuple_impl&) SPROUT_NOEXCEPT {}
-			public:
-				tuple_impl() = default;
-				template<typename... UTypes>
-				explicit SPROUT_CONSTEXPR tuple_impl(UTypes&&... args) SPROUT_NOEXCEPT {}
-				SPROUT_CONSTEXPR tuple_impl(tuple_impl const&) = default;
-				SPROUT_CONSTEXPR tuple_impl(tuple_impl&&) = default;
-				template<typename... UTypes>
-				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index, UTypes...> const& t) SPROUT_NOEXCEPT {}
-				template<typename... UTypes>
-				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index, UTypes...>&& t) SPROUT_NOEXCEPT {}
-				tuple_impl& operator=(tuple_impl const&) = default;
-				tuple_impl& operator=(tuple_impl&& t) = default;
-				template<typename... UTypes>
-				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index, UTypes...> const&) SPROUT_NOEXCEPT {
-					return *this;
-				}
-				template<typename... UTypes>
-				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index, UTypes...>&&) SPROUT_NOEXCEPT {
-					return *this;
-				}
-			};
-			template<std::size_t Index, typename Head, typename... Tail>
-			class tuple_impl<Index, Head, Tail...>
-				: public sprout::tuples::detail::tuple_impl<Index + 1, Tail...>
-				, private sprout::tuples::detail::head_base<Index, Head, std::is_empty<Head>::value>
-			{
-			public:
-				template<std::size_t, typename...>
-				friend class sprout::tuples::detail::tuple_impl;
-			public:
-				typedef sprout::tuples::detail::tuple_impl<Index + 1, Tail...> inherited_type;
-				typedef sprout::tuples::detail::head_base<Index, Head, std::is_empty<Head>::value> base_type;
-			public:
-				static SPROUT_CONSTEXPR Head& head(tuple_impl& t) SPROUT_NOEXCEPT {
-					return base_type::head(t);
-				}
-				static SPROUT_CONSTEXPR Head const& head(tuple_impl const& t) SPROUT_NOEXCEPT {
-					return base_type::head(t);
-				}
-				static SPROUT_CONSTEXPR inherited_type& tail(tuple_impl& t) SPROUT_NOEXCEPT {
-					return t;
-				}
-				static SPROUT_CONSTEXPR inherited_type const& tail(tuple_impl const& t) SPROUT_NOEXCEPT {
-					return t;
-				}
-			protected:
-				void swap(tuple_impl& t) SPROUT_NOEXCEPT_EXPR(
-					SPROUT_NOEXCEPT_EXPR(swap(std::declval<Head&>(), std::declval<Head&>()))
-					&& SPROUT_NOEXCEPT_EXPR(tail(t).swap(tail(t)))
-					)
-				{
-					using std::swap;
-					swap(head(*this), head(t));
-					inherited_type::swap(tail(t));
-				}
-			public:
-				SPROUT_CONSTEXPR tuple_impl()
-					: inherited_type()
-					, base_type()
-				{}
-				explicit SPROUT_CONSTEXPR tuple_impl(Head const& h, Tail const&... tail)
-					: inherited_type(tail...)
-					, base_type(h)
-				{}
-				template<typename UHead, typename... UTail>
-				explicit SPROUT_CONSTEXPR tuple_impl(UHead&& h, UTail&&... tail)
-					: inherited_type(sprout::forward<UTail>(tail)...)
-					, base_type(sprout::forward<UHead>(h))
-				{}
-				SPROUT_CONSTEXPR tuple_impl(tuple_impl const&) = default;
-				SPROUT_CONSTEXPR tuple_impl(tuple_impl&& t)
-				SPROUT_NOEXCEPT_EXPR(std::is_nothrow_move_constructible<Head>::value && std::is_nothrow_move_constructible<inherited_type>::value)
-					: inherited_type(sprout::move(tail(t)))
-					, base_type(sprout::forward<Head>(head(t)))
-				{}
-				template<typename... UTypes>
-				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index, UTypes...> const& t)
-					: inherited_type(sprout::tuples::detail::tuple_impl<Index, UTypes...>::tail(t))
-					, base_type(sprout::tuples::detail::tuple_impl<Index, UTypes...>::head(t))
-				{}
-				template<typename UHead, typename... UTail>
-				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index, UHead, UTail...>&& t)
-					: inherited_type(sprout::move(sprout::tuples::detail::tuple_impl<Index, UHead, UTail...>::tail(t)))
-					, base_type(sprout::forward<UHead>(sprout::tuples::detail::tuple_impl<Index, UHead, UTail...>::head(t)))
-				{}
-				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index> const& t)
-					: inherited_type()
-					, base_type()
-				{}
-				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index>&& t)
-					: inherited_type()
-					, base_type()
-				{}
-				tuple_impl& operator=(tuple_impl const& t) {
-					head(*this) = head(t);
-					tail(*this) = tail(t);
-					return *this;
-				}
-				tuple_impl& operator=(tuple_impl&& t)
-				SPROUT_NOEXCEPT_EXPR(std::is_nothrow_move_assignable<Head>::value && std::is_nothrow_move_assignable<inherited_type>::value)
-				{
-					head(*this) = sprout::forward<Head>(head(t));
-					tail(*this) = sprout::move(tail(t));
-					return *this;
-				}
-				template<typename... UTypes>
-				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index, UTypes...> const& t) {
-					head(*this) = sprout::tuples::detail::tuple_impl<Index, UTypes...>::head(t);
-					tail(*this) = sprout::tuples::detail::tuple_impl<Index, UTypes...>::tail(t);
-					return *this;
-				}
-				template<typename UHead, typename... UTail>
-				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index, UHead, UTail...>&& t) {
-					head(*this) = sprout::forward<UHead>(sprout::tuples::detail::tuple_impl<Index, UHead, UTail...>::head(t));
-					tail(*this) = sprout::move(sprout::tuples::detail::tuple_impl<Index, UHead, UTail...>::tail(t));
-					return *this;
-				}
-				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index> const& t) {
-					*this = sprout::move(tuple_impl());
-					return *this;
-				}
-				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index>&& t) {
-					*this = sprout::move(tuple_impl());
-					return *this;
-				}
-			};
-
-			template<bool Head, bool... Tail>
-			struct and_impl;
-			template<>
-			struct and_impl<true>
-				: public std::true_type
-			{};
-			template<>
-			struct and_impl<false>
-				: public std::false_type
-			{};
-			template<bool... Tail>
-			struct and_impl<true, Tail...>
-				: public std::integral_constant<bool, sprout::tuples::detail::and_impl<Tail...>::value>
-			{};
-			template<bool... Tail>
-			struct and_impl<false, Tail...>
-				: public std::false_type
-			{};
-			template<typename... Types>
-			struct and_
-				: public sprout::tuples::detail::and_impl<Types::value...>
-			{};
-
-			template<bool Head, bool... Tail>
-			struct or_impl;
-			template<>
-			struct or_impl<true>
-				: public std::true_type
-			{};
-			template<>
-			struct or_impl<false>
-				: public std::false_type
-			{};
-			template<bool... Tail>
-			struct or_impl<true, Tail...>
-				: public std::true_type
-			{};
-			template<bool... Tail>
-			struct or_impl<false, Tail...>
-				: public std::integral_constant<bool, sprout::tuples::detail::or_impl<Tail...>::value>
-			{};
-			template<typename... Types>
-			struct or_
-				: public sprout::tuples::detail::and_impl<Types::value...>
-			{};
-		}	// namespace detail
-
-		template<typename... Types>
-		class tuple;
-
-		//
-		// is_tuple
-		//
-		template<typename T>
-		struct is_tuple
-			: public std::false_type
-		{};
-		template<typename T>
-		struct is_tuple<T const>
-			: public sprout::tuples::is_tuple<T>
-		{};
-		template<typename T>
-		struct is_tuple<T const volatile>
-			: public sprout::tuples::is_tuple<T>
-		{};
-		template<typename... Types>
-		struct is_tuple<sprout::tuples::tuple<Types...> >
-			: public std::true_type
-		{};
-
-		//
-		// tuple
-		//
-		template<typename... Types>
-		class tuple
-			: public sprout::tuples::detail::tuple_impl<0, Types...>
-		{
-		public:
-			typedef sprout::tuples::detail::tuple_impl<0, Types...> inherited_type;
-		public:
-			// tuple construction
-			SPROUT_CONSTEXPR tuple()
-				: inherited_type()
-			{}
-			explicit SPROUT_CONSTEXPR tuple(Types const&... elements)
-				: inherited_type(elements...)
-			{}
-			template<
-				typename U,
-				typename = typename std::enable_if<
-					!sprout::tuples::is_tuple<typename std::remove_reference<U>::type>::value
-				>::type
-			>
-			explicit SPROUT_CONSTEXPR tuple(U&& elem)
-				: inherited_type(sprout::forward<U>(elem))
-			{}
-			template<
-				typename U1,
-				typename U2,
-				typename... UTypes
-			>
-			explicit SPROUT_CONSTEXPR tuple(U1&& elem1, U2&& elem2, UTypes&&... elements)
-				: inherited_type(sprout::forward<U1>(elem1), sprout::forward<U2>(elem2), sprout::forward<UTypes>(elements)...)
-			{}
-			SPROUT_CONSTEXPR tuple(tuple const&) = default;
-			SPROUT_CONSTEXPR tuple(tuple&&) = default;
-			template<typename... UTypes>
-			SPROUT_CONSTEXPR tuple(sprout::tuples::tuple<UTypes...> const& t)
-				: inherited_type(static_cast<sprout::tuples::detail::tuple_impl<0, UTypes...> const&>(t))
-			{}
-			template<typename... UTypes>
-			SPROUT_CONSTEXPR tuple(sprout::tuples::tuple<UTypes...>&& t)
-				: inherited_type(static_cast<sprout::tuples::detail::tuple_impl<0, UTypes...>&&>(t))
-			{}
-			// tuple assignment
-			tuple& operator=(tuple const& rhs) {
-				static_cast<inherited_type&>(*this) = rhs;
-				return *this;
-			}
-			tuple& operator=(tuple&& rhs) SPROUT_NOEXCEPT_EXPR(std::is_nothrow_move_assignable<inherited_type>::value) {
-				static_cast<inherited_type&>(*this) = sprout::move(rhs);
-				return *this;
-			}
-			template<typename... UTypes>
-			tuple& operator=(sprout::tuples::tuple<UTypes...> const& rhs) {
-				static_cast<inherited_type&>(*this) = rhs;
-				return *this;
-			}
-			template<typename... UTypes>
-			tuple& operator=(sprout::tuples::tuple<UTypes...>&& rhs) {
-				static_cast<inherited_type&>(*this) = sprout::move(rhs);
-				return *this;
-			}
-			// tuple swap
-			void swap(tuple& other) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(inherited_type::swap(other))) {
-				inherited_type::swap(other);
-			}
-		};
-		template<>
-		class tuple<> {
-		public:
-			// tuple swap
-			void swap(tuple&) SPROUT_NOEXCEPT {}
-		};
-
-		//
-		// ignore_t
-		//
-		struct ignore_t {
-			template<typename T>
-			ignore_t const& operator=(T const&) const {
-				return *this;
-			}
-		};
-		//
-		// ignore
-		//
-		SPROUT_STATIC_CONSTEXPR ignore_t ignore{};
-
-		//
-		// make_tuple
-		//
-		template<typename... Types>
-		inline SPROUT_CONSTEXPR sprout::tuples::tuple<typename std::decay<Types>::type...> make_tuple(Types&&... args) {
-			return sprout::tuples::tuple<typename std::decay<Types>::type...>(sprout::forward<Types>(args)...);
-		}
-		//
-		// forward_as_tuple
-		//
-		template<typename... Types>
-		inline SPROUT_CONSTEXPR sprout::tuples::tuple<Types&&...> forward_as_tuple(Types&&... args) SPROUT_NOEXCEPT {
-			return sprout::tuples::tuple<Types&&...>(sprout::forward<Types>(args)...);
-		}
-		//
-		// tie
-		//
-		template<typename... Types>
-		inline sprout::tuples::tuple<Types&...> tie(Types&... args) SPROUT_NOEXCEPT {
-			return sprout::tuples::tuple<Types&...>(args...);
-		}
-
-		//
-		// swap
-		//
-		template<typename... Types>
-		inline void swap(
-			sprout::tuples::tuple<Types...>& lhs,
-			sprout::tuples::tuple<Types...>& rhs
-			) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
-		{
-			lhs.swap(rhs);
-		}
-
-		namespace detail {
-			template<std::size_t I, typename T>
-			struct tuple_element_impl;
-			template<typename Head, typename... Tail>
-			struct tuple_element_impl<0, sprout::tuples::tuple<Head, Tail...> > {
-			public:
-				typedef Head type;
-			};
-			template<std::size_t I, typename Head, typename... Tail>
-			struct tuple_element_impl<I, sprout::tuples::tuple<Head, Tail...> >
-				: public sprout::tuples::detail::tuple_element_impl<I - 1, sprout::tuples::tuple<Tail...> >
-			{};
-		}	// namespace detail
-	}	// namespace tuples
-
-	using sprout::tuples::tuple;
-	using sprout::tuples::ignore;
-	using sprout::tuples::make_tuple;
-	using sprout::tuples::forward_as_tuple;
-	using sprout::tuples::tie;
-	using sprout::tuples::swap;
-}	// namespace sprout
-
-namespace std {
-	//
-	// tuple_size
-	//
-	template<typename... Types>
-	struct tuple_size<sprout::tuples::tuple<Types...> >
-		: public std::integral_constant<std::size_t, sizeof...(Types)>
-	{};
-
-	//
-	// tuple_element
-	//
-	template<std::size_t I, typename... Types>
-	struct tuple_element<I, sprout::tuples::tuple<Types...> >
-		: public sprout::tuples::detail::tuple_element_impl<I, sprout::tuples::tuple<Types...> >
-	{};
-}	// namespace std
-
-namespace sprout {
-	namespace tuples {
-		//
-		// tuple_size
-		//
-		template<typename T>
-		struct tuple_size
-			: public std::tuple_size<T>
-		{};
-		template<typename T>
-		struct tuple_size<T const>
-			: public sprout::tuples::tuple_size<T>
-		{};
-		template<typename T>
-		struct tuple_size<T volatile>
-			: public sprout::tuples::tuple_size<T>
-		{};
-		template<typename T>
-		struct tuple_size<T const volatile>
-			: public sprout::tuples::tuple_size<T>
-		{};
-
-		//
-		// tuple_element
-		//
-		template<std::size_t I, typename T>
-		struct tuple_element
-			: public std::tuple_element<I, T>
-		{};
-		template<std::size_t I, typename T>
-		struct tuple_element<I, T const>
-			: public sprout::tuples::tuple_element<I, T>
-		{};
-		template<std::size_t I, typename T>
-		struct tuple_element<I, T volatile>
-			: public sprout::tuples::tuple_element<I, T>
-		{};
-		template<std::size_t I, typename T>
-		struct tuple_element<I, T const volatile>
-			: public sprout::tuples::tuple_element<I, T>
-		{};
-
-		//
-		// get
-		//
-		template<std::size_t I, typename T>
-		inline SPROUT_CONSTEXPR auto
-		get(T&& t) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(std::get<I>(sprout::forward<T>(t))))
-			-> decltype(std::get<I>(sprout::forward<T>(t)))
-		{
-			return std::get<I>(sprout::forward<T>(t));
-		}
-		//
-		// get
-		//
-		namespace detail {
-			template<std::size_t I, typename Head, typename... Tail>
-			inline SPROUT_CONSTEXPR typename std::add_lvalue_reference<Head>::type
-			get_helper(sprout::tuples::detail::tuple_impl<I, Head, Tail...>& t) SPROUT_NOEXCEPT {
-				return sprout::tuples::detail::tuple_impl<I, Head, Tail...>::head(t);
-			}
-			template<std::size_t I, typename Head, typename... Tail>
-			inline SPROUT_CONSTEXPR typename std::add_lvalue_reference<typename std::add_const<Head>::type>::type
-			get_helper(sprout::tuples::detail::tuple_impl<I, Head, Tail...> const& t) SPROUT_NOEXCEPT {
-				return sprout::tuples::detail::tuple_impl<I, Head, Tail...>::head(t);
-			}
-		}	// namespace detail
-		template<std::size_t I, typename... Types>
-		inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::tuples::tuple<Types...> >::type&
-		get(sprout::tuples::tuple<Types...>& t) SPROUT_NOEXCEPT {
-			return sprout::tuples::detail::get_helper<I>(t);
-		}
-		template<std::size_t I, typename... Types>
-		inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::tuples::tuple<Types...> >::type&&
-		get(sprout::tuples::tuple<Types...>&& t) SPROUT_NOEXCEPT {
-			return sprout::forward<typename sprout::tuples::tuple_element<I, sprout::tuples::tuple<Types...> >::type&&>(
-				sprout::tuples::get<I>(t)
-				);
-		}
-		template<std::size_t I, typename... Types>
-		inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::tuples::tuple<Types...> >::type const&
-		get(sprout::tuples::tuple<Types...> const& t) SPROUT_NOEXCEPT {
-			return sprout::tuples::detail::get_helper<I>(t);
-		}
-	}	// namespace tuples
-
-	using sprout::tuples::tuple_size;
-	using sprout::tuples::tuple_element;
-	using sprout::tuples::get;
-}	// namespace sprout
-
-#include <sprout/tuple/tuple_comparison.hpp>
+#include <sprout/tuple/tuple/tuple_fwd.hpp>
+#include <sprout/tuple/tuple/tuple.hpp>
+#include <sprout/tuple/tuple/get.hpp>
+#include <sprout/tuple/tuple/ignore.hpp>
+#include <sprout/tuple/tuple/make_tuple.hpp>
+#include <sprout/tuple/tuple/comparison.hpp>
+#include <sprout/tuple/tuple/type_traits.hpp>
 
 #endif	// #ifndef SPROUT_TUPLE_TUPLE_HPP
diff --git a/sprout/tuple/tuple_comparison.hpp b/sprout/tuple/tuple/comparison.hpp
similarity index 94%
rename from sprout/tuple/tuple_comparison.hpp
rename to sprout/tuple/tuple/comparison.hpp
index 95047fdc..17712adb 100644
--- a/sprout/tuple/tuple_comparison.hpp
+++ b/sprout/tuple/tuple/comparison.hpp
@@ -3,7 +3,8 @@
 
 #include <cstddef>
 #include <sprout/config.hpp>
-#include <sprout/tuple/tuple.hpp>
+#include <sprout/tuple/tuple/tuple.hpp>
+#include <sprout/tuple/tuple/get.hpp>
 
 namespace sprout {
 	namespace tuples {
diff --git a/sprout/tuple/tuple/get.hpp b/sprout/tuple/tuple/get.hpp
new file mode 100644
index 00000000..8b8897f1
--- /dev/null
+++ b/sprout/tuple/tuple/get.hpp
@@ -0,0 +1,102 @@
+#ifndef SPROUT_TUPLE_TUPLE_GET_HPP
+#define SPROUT_TUPLE_TUPLE_GET_HPP
+
+#include <cstddef>
+#include <type_traits>
+#include <tuple>
+#include <sprout/config.hpp>
+#include <sprout/utility/forward.hpp>
+#include <sprout/tuple/tuple/tuple.hpp>
+
+namespace sprout {
+	namespace tuples {
+		//
+		// tuple_size
+		//
+		template<typename T>
+		struct tuple_size
+			: public std::tuple_size<T>
+		{};
+		template<typename T>
+		struct tuple_size<T const>
+			: public sprout::tuples::tuple_size<T>
+		{};
+		template<typename T>
+		struct tuple_size<T volatile>
+			: public sprout::tuples::tuple_size<T>
+		{};
+		template<typename T>
+		struct tuple_size<T const volatile>
+			: public sprout::tuples::tuple_size<T>
+		{};
+
+		//
+		// tuple_element
+		//
+		template<std::size_t I, typename T>
+		struct tuple_element
+			: public std::tuple_element<I, T>
+		{};
+		template<std::size_t I, typename T>
+		struct tuple_element<I, T const>
+			: public sprout::tuples::tuple_element<I, T>
+		{};
+		template<std::size_t I, typename T>
+		struct tuple_element<I, T volatile>
+			: public sprout::tuples::tuple_element<I, T>
+		{};
+		template<std::size_t I, typename T>
+		struct tuple_element<I, T const volatile>
+			: public sprout::tuples::tuple_element<I, T>
+		{};
+
+		//
+		// get
+		//
+		template<std::size_t I, typename T>
+		inline SPROUT_CONSTEXPR auto
+		get(T&& t) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(std::get<I>(sprout::forward<T>(t))))
+			-> decltype(std::get<I>(sprout::forward<T>(t)))
+		{
+			return std::get<I>(sprout::forward<T>(t));
+		}
+		//
+		// get
+		//
+		namespace detail {
+			template<std::size_t I, typename Head, typename... Tail>
+			inline SPROUT_CONSTEXPR typename std::add_lvalue_reference<Head>::type
+			get_helper(sprout::tuples::detail::tuple_impl<I, Head, Tail...>& t) SPROUT_NOEXCEPT {
+				return sprout::tuples::detail::tuple_impl<I, Head, Tail...>::head(t);
+			}
+			template<std::size_t I, typename Head, typename... Tail>
+			inline SPROUT_CONSTEXPR typename std::add_lvalue_reference<typename std::add_const<Head>::type>::type
+			get_helper(sprout::tuples::detail::tuple_impl<I, Head, Tail...> const& t) SPROUT_NOEXCEPT {
+				return sprout::tuples::detail::tuple_impl<I, Head, Tail...>::head(t);
+			}
+		}	// namespace detail
+		template<std::size_t I, typename... Types>
+		inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::tuples::tuple<Types...> >::type&
+		get(sprout::tuples::tuple<Types...>& t) SPROUT_NOEXCEPT {
+			return sprout::tuples::detail::get_helper<I>(t);
+		}
+		template<std::size_t I, typename... Types>
+		inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::tuples::tuple<Types...> >::type&&
+		get(sprout::tuples::tuple<Types...>&& t) SPROUT_NOEXCEPT {
+			return sprout::forward<typename sprout::tuples::tuple_element<I, sprout::tuples::tuple<Types...> >::type&&>(
+				sprout::tuples::get<I>(t)
+				);
+		}
+		template<std::size_t I, typename... Types>
+		inline SPROUT_CONSTEXPR typename sprout::tuples::tuple_element<I, sprout::tuples::tuple<Types...> >::type const&
+		get(sprout::tuples::tuple<Types...> const& t) SPROUT_NOEXCEPT {
+			return sprout::tuples::detail::get_helper<I>(t);
+		}
+	}	// namespace tuples
+
+	using sprout::tuples::tuple_size;
+	using sprout::tuples::tuple_element;
+	using sprout::tuples::get;
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TUPLE_TUPLE_GET_HPP
diff --git a/sprout/tuple/tuple/ignore.hpp b/sprout/tuple/tuple/ignore.hpp
new file mode 100644
index 00000000..3d0a6f43
--- /dev/null
+++ b/sprout/tuple/tuple/ignore.hpp
@@ -0,0 +1,28 @@
+#ifndef SPROUT_TUPLE_TUPLE_IGNORE_HPP
+#define SPROUT_TUPLE_TUPLE_IGNORE_HPP
+
+#include <sprout/config.hpp>
+
+namespace sprout {
+	namespace tuples {
+		//
+		// ignore_t
+		//
+		struct ignore_t {
+		public:
+			template<typename T>
+			ignore_t const& operator=(T const&) const {
+				return *this;
+			}
+		};
+		//
+		// ignore
+		//
+		SPROUT_STATIC_CONSTEXPR ignore_t ignore{};
+	}	// namespace tuples
+
+	using sprout::tuples::ignore_t;
+	using sprout::tuples::ignore;
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TUPLE_TUPLE_IGNORE_HPP
diff --git a/sprout/tuple/tuple/make_tuple.hpp b/sprout/tuple/tuple/make_tuple.hpp
new file mode 100644
index 00000000..30f2491e
--- /dev/null
+++ b/sprout/tuple/tuple/make_tuple.hpp
@@ -0,0 +1,163 @@
+#ifndef SPROUT_TUPLE_TUPLE_MAKE_TUPLE_HPP
+#define SPROUT_TUPLE_TUPLE_MAKE_TUPLE_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/index_tuple.hpp>
+#include <sprout/utility/forward.hpp>
+#include <sprout/tuple/tuple/tuple.hpp>
+#include <sprout/tuple/tuple/get.hpp>
+
+namespace sprout {
+	namespace tuples {
+		//
+		// make_tuple
+		//
+		template<typename... Types>
+		inline SPROUT_CONSTEXPR sprout::tuples::tuple<typename std::decay<Types>::type...> make_tuple(Types&&... args) {
+			return sprout::tuples::tuple<typename std::decay<Types>::type...>(sprout::forward<Types>(args)...);
+		}
+
+		//
+		// forward_as_tuple
+		//
+		template<typename... Types>
+		inline SPROUT_CONSTEXPR sprout::tuples::tuple<Types&&...> forward_as_tuple(Types&&... args) SPROUT_NOEXCEPT {
+			return sprout::tuples::tuple<Types&&...>(sprout::forward<Types>(args)...);
+		}
+
+		//
+		// tie
+		//
+		template<typename... Types>
+		inline sprout::tuples::tuple<Types&...> tie(Types&... args) SPROUT_NOEXCEPT {
+			return sprout::tuples::tuple<Types&...>(args...);
+		}
+
+		namespace result_of {
+			namespace detail {
+				template<typename... Tuples>
+				struct tuple_cat_impl;
+				template<>
+				struct tuple_cat_impl<> {
+					typedef sprout::tuples::tuple<> type;
+				};
+				template<typename Tuple>
+				struct tuple_cat_impl<Tuple> {
+				private:
+					template<typename Tup, typename IndexTuple>
+					struct make;
+					template<typename Tup, sprout::index_t... Indexes>
+					struct make<Tup, sprout::index_tuple<Indexes...> > {
+					public:
+						typedef sprout::tuples::tuple<typename sprout::tuples::tuple_element<Indexes, Tup>::type...> type;
+					};
+				public:
+					typedef typename make<
+						Tuple, typename sprout::index_range<0, sprout::tuples::tuple_size<Tuple>::value>::type
+					>::type type;
+				};
+				template<typename T, typename U, typename... Tuples>
+				struct tuple_cat_impl<T, U, Tuples...> {
+				private:
+					template<typename Tup1, typename IndexTuple1, typename Tup2, typename IndexTuple2>
+					struct make;
+					template<typename Tup1, sprout::index_t... Indexes1, typename Tup2, sprout::index_t... Indexes2>
+					struct make<Tup1, sprout::index_tuple<Indexes1...>, Tup2, sprout::index_tuple<Indexes2...> > {
+					public:
+						typedef sprout::tuples::tuple<
+							typename sprout::tuples::tuple_element<Indexes1, Tup1>::type...,
+							typename sprout::tuples::tuple_element<Indexes2, Tup2>::type...
+						> type;
+					};
+				public:
+					typedef typename sprout::tuples::result_of::detail::tuple_cat_impl<
+						typename make<
+							T, typename sprout::index_range<0, sprout::tuples::tuple_size<T>::value>::type,
+							U, typename sprout::index_range<0, sprout::tuples::tuple_size<U>::value>::type
+						>::type,
+						Tuples...
+					>::type type;
+				};
+			}	// namespace detail
+			//
+			// tuple_cat
+			//
+			template<typename... Tuples>
+			struct tuple_cat
+				: public sprout::tuples::result_of::detail::tuple_cat_impl<
+					typename std::remove_reference<Tuples>::type...
+				>
+			{};
+		}	// namespace result_of
+
+		namespace detail {
+			template<typename... Tuples>
+			struct tuple_cat_1st_indexes;
+			template<>
+			struct tuple_cat_1st_indexes<> {
+			public:
+				typedef sprout::index_tuple<> type;
+			};
+			template<typename Head, typename... Tail>
+			struct tuple_cat_1st_indexes<Head, Tail...> {
+			public:
+				typedef typename sprout::index_range<
+					0, sprout::tuples::tuple_size<typename std::remove_reference<Head>::type>::value
+				>::type type;
+			};
+
+			template<typename Result, typename IndexTuple, typename... Tuples>
+			struct tuple_cat_impl;
+			template<typename Result, sprout::index_t... Indexes, typename Head, typename... Tail>
+			struct tuple_cat_impl<Result, sprout::index_tuple<Indexes...>, Head, Tail...> {
+			public:
+				template<typename... Args>
+				static SPROUT_CONSTEXPR Result
+				call(Head&& head, Tail&&... tail, Args&&... args) {
+					return sprout::tuples::detail::tuple_cat_impl<
+						Result,
+						typename sprout::tuples::detail::tuple_cat_1st_indexes<Tail...>::type,
+						Tail...
+					>::call(
+						sprout::forward<Tail>(tail)...,
+						sprout::forward<Args>(args)...,
+						sprout::tuples::get<Indexes>(sprout::forward<Head>(head))...
+						);
+				}
+			};
+			template<typename Result>
+			struct tuple_cat_impl<Result, sprout::index_tuple<> > {
+			public:
+				template<typename... Args>
+				static SPROUT_CONSTEXPR Result
+				call(Args&&... args) {
+					return Result(sprout::forward<Args>(args)...);
+				}
+			};
+		}	// namespace detail
+		//
+		// tuple_cat
+		//
+		template<typename... Tuples>
+		inline SPROUT_CONSTEXPR typename sprout::tuples::result_of::tuple_cat<Tuples...>::type
+		tuple_cat(Tuples&&... tuples) {
+			return sprout::tuples::detail::tuple_cat_impl<
+				typename sprout::tuples::result_of::tuple_cat<Tuples...>::type,
+				typename sprout::tuples::detail::tuple_cat_1st_indexes<Tuples...>::type,
+				Tuples...
+			>::call(sprout::forward<Tuples>(tuples)...);
+		}
+	}	// namespace tuples
+
+	namespace result_of {
+		using sprout::tuples::result_of::tuple_cat;
+	}	// namespace result_of
+
+	using sprout::tuples::make_tuple;
+	using sprout::tuples::forward_as_tuple;
+	using sprout::tuples::tie;
+	using sprout::tuples::tuple_cat;
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TUPLE_TUPLE_MAKE_TUPLE_HPP
diff --git a/sprout/tuple/tuple/tuple.hpp b/sprout/tuple/tuple/tuple.hpp
new file mode 100644
index 00000000..4245299c
--- /dev/null
+++ b/sprout/tuple/tuple/tuple.hpp
@@ -0,0 +1,397 @@
+#ifndef SPROUT_TUPLE_TUPLE_TUPLE_HPP
+#define SPROUT_TUPLE_TUPLE_TUPLE_HPP
+
+#include <cstddef>
+#include <utility>
+#include <type_traits>
+#include <tuple>
+#include <sprout/config.hpp>
+#include <sprout/utility/operation.hpp>
+#include <sprout/tuple/tuple/tuple_fwd.hpp>
+#include <sprout/tuple/tuple/type_traits.hpp>
+
+namespace sprout {
+	namespace tuples {
+		namespace detail {
+			template<std::size_t Index, typename Head, bool IsEmpty>
+			class head_base;
+			//!!!
+			// EBO disabled
+//			template<std::size_t Index, typename Head>
+//			class head_base<Index, Head, true>
+//				: public Head
+//			{
+//			public:
+//				static SPROUT_CONSTEXPR Head& head(head_base& t) SPROUT_NOEXCEPT {
+//					return t;
+//				}
+//				static SPROUT_CONSTEXPR Head const& head(head_base const& t) SPROUT_NOEXCEPT {
+//					return t;
+//				}
+//			public:
+//				SPROUT_CONSTEXPR head_base()
+//					: Head()
+//				{}
+//				SPROUT_CONSTEXPR head_base(Head const& v)
+//					: Head(v)
+//				{}
+//				template<typename UHead>
+//				SPROUT_CONSTEXPR head_base(UHead&& v)
+//					: Head(sprout::forward<UHead>(v))
+//				{}
+//			};
+			template<std::size_t Index, typename Head>
+			class head_base<Index, Head, true> {
+			public:
+				static SPROUT_CONSTEXPR Head& head(head_base& t) SPROUT_NOEXCEPT {
+					return t.head_;
+				}
+				static SPROUT_CONSTEXPR Head const& head(head_base const& t) SPROUT_NOEXCEPT {
+					return t.head_;
+				}
+			private:
+				Head head_;
+			public:
+				SPROUT_CONSTEXPR head_base()
+					: head_()
+				{}
+				SPROUT_CONSTEXPR head_base(Head const& v)
+					: head_(v)
+				{}
+				template<typename UHead>
+				SPROUT_CONSTEXPR head_base(UHead&& v)
+					: head_(sprout::forward<UHead>(v))
+				{}
+			};
+			template<std::size_t Index, typename Head>
+			class head_base<Index, Head, false> {
+			public:
+				static SPROUT_CONSTEXPR Head& head(head_base& t) SPROUT_NOEXCEPT {
+					return t.head_;
+				}
+				static SPROUT_CONSTEXPR Head const& head(head_base const& t) SPROUT_NOEXCEPT {
+					return t.head_;
+				}
+			private:
+				Head head_;
+			public:
+				SPROUT_CONSTEXPR head_base()
+					: head_()
+				{}
+				SPROUT_CONSTEXPR head_base(Head const& v)
+					: head_(v)
+				{}
+				template<typename UHead>
+				SPROUT_CONSTEXPR head_base(UHead&& v)
+					: head_(sprout::forward<UHead>(v))
+				{}
+			};
+
+			template<std::size_t Index, typename... Types>
+			class tuple_impl;
+			template<std::size_t Index>
+			class tuple_impl<Index> {
+			public:
+				template<std::size_t, typename...>
+				friend class sprout::tuples::detail::tuple_impl;
+			protected:
+				void swap(tuple_impl&) SPROUT_NOEXCEPT {}
+			public:
+				tuple_impl() = default;
+				template<typename... UTypes>
+				explicit SPROUT_CONSTEXPR tuple_impl(UTypes&&... args) SPROUT_NOEXCEPT {}
+				SPROUT_CONSTEXPR tuple_impl(tuple_impl const&) = default;
+				SPROUT_CONSTEXPR tuple_impl(tuple_impl&&) = default;
+				template<typename... UTypes>
+				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index, UTypes...> const& t) SPROUT_NOEXCEPT {}
+				template<typename... UTypes>
+				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index, UTypes...>&& t) SPROUT_NOEXCEPT {}
+				tuple_impl& operator=(tuple_impl const&) = default;
+				tuple_impl& operator=(tuple_impl&& t) = default;
+				template<typename... UTypes>
+				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index, UTypes...> const&) SPROUT_NOEXCEPT {
+					return *this;
+				}
+				template<typename... UTypes>
+				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index, UTypes...>&&) SPROUT_NOEXCEPT {
+					return *this;
+				}
+			};
+			template<std::size_t Index, typename Head, typename... Tail>
+			class tuple_impl<Index, Head, Tail...>
+				: public sprout::tuples::detail::tuple_impl<Index + 1, Tail...>
+				, private sprout::tuples::detail::head_base<Index, Head, std::is_empty<Head>::value>
+			{
+			public:
+				template<std::size_t, typename...>
+				friend class sprout::tuples::detail::tuple_impl;
+			public:
+				typedef sprout::tuples::detail::tuple_impl<Index + 1, Tail...> inherited_type;
+				typedef sprout::tuples::detail::head_base<Index, Head, std::is_empty<Head>::value> base_type;
+			public:
+				static SPROUT_CONSTEXPR Head& head(tuple_impl& t) SPROUT_NOEXCEPT {
+					return base_type::head(t);
+				}
+				static SPROUT_CONSTEXPR Head const& head(tuple_impl const& t) SPROUT_NOEXCEPT {
+					return base_type::head(t);
+				}
+				static SPROUT_CONSTEXPR inherited_type& tail(tuple_impl& t) SPROUT_NOEXCEPT {
+					return t;
+				}
+				static SPROUT_CONSTEXPR inherited_type const& tail(tuple_impl const& t) SPROUT_NOEXCEPT {
+					return t;
+				}
+			protected:
+				void swap(tuple_impl& t) SPROUT_NOEXCEPT_EXPR(
+					SPROUT_NOEXCEPT_EXPR(swap(std::declval<Head&>(), std::declval<Head&>()))
+					&& SPROUT_NOEXCEPT_EXPR(tail(t).swap(tail(t)))
+					)
+				{
+					using std::swap;
+					swap(head(*this), head(t));
+					inherited_type::swap(tail(t));
+				}
+			public:
+				SPROUT_CONSTEXPR tuple_impl()
+					: inherited_type()
+					, base_type()
+				{}
+				explicit SPROUT_CONSTEXPR tuple_impl(Head const& h, Tail const&... tail)
+					: inherited_type(tail...)
+					, base_type(h)
+				{}
+				template<typename UHead, typename... UTail>
+				explicit SPROUT_CONSTEXPR tuple_impl(UHead&& h, UTail&&... tail)
+					: inherited_type(sprout::forward<UTail>(tail)...)
+					, base_type(sprout::forward<UHead>(h))
+				{}
+				SPROUT_CONSTEXPR tuple_impl(tuple_impl const&) = default;
+				SPROUT_CONSTEXPR tuple_impl(tuple_impl&& t)
+				SPROUT_NOEXCEPT_EXPR(std::is_nothrow_move_constructible<Head>::value && std::is_nothrow_move_constructible<inherited_type>::value)
+					: inherited_type(sprout::move(tail(t)))
+					, base_type(sprout::forward<Head>(head(t)))
+				{}
+				template<typename... UTypes>
+				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index, UTypes...> const& t)
+					: inherited_type(sprout::tuples::detail::tuple_impl<Index, UTypes...>::tail(t))
+					, base_type(sprout::tuples::detail::tuple_impl<Index, UTypes...>::head(t))
+				{}
+				template<typename UHead, typename... UTail>
+				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index, UHead, UTail...>&& t)
+					: inherited_type(sprout::move(sprout::tuples::detail::tuple_impl<Index, UHead, UTail...>::tail(t)))
+					, base_type(sprout::forward<UHead>(sprout::tuples::detail::tuple_impl<Index, UHead, UTail...>::head(t)))
+				{}
+				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index> const& t)
+					: inherited_type()
+					, base_type()
+				{}
+				SPROUT_CONSTEXPR tuple_impl(tuple_impl<Index>&& t)
+					: inherited_type()
+					, base_type()
+				{}
+				tuple_impl& operator=(tuple_impl const& t) {
+					head(*this) = head(t);
+					tail(*this) = tail(t);
+					return *this;
+				}
+				tuple_impl& operator=(tuple_impl&& t)
+				SPROUT_NOEXCEPT_EXPR(std::is_nothrow_move_assignable<Head>::value && std::is_nothrow_move_assignable<inherited_type>::value)
+				{
+					head(*this) = sprout::forward<Head>(head(t));
+					tail(*this) = sprout::move(tail(t));
+					return *this;
+				}
+				template<typename... UTypes>
+				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index, UTypes...> const& t) {
+					head(*this) = sprout::tuples::detail::tuple_impl<Index, UTypes...>::head(t);
+					tail(*this) = sprout::tuples::detail::tuple_impl<Index, UTypes...>::tail(t);
+					return *this;
+				}
+				template<typename UHead, typename... UTail>
+				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index, UHead, UTail...>&& t) {
+					head(*this) = sprout::forward<UHead>(sprout::tuples::detail::tuple_impl<Index, UHead, UTail...>::head(t));
+					tail(*this) = sprout::move(sprout::tuples::detail::tuple_impl<Index, UHead, UTail...>::tail(t));
+					return *this;
+				}
+				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index> const& t) {
+					*this = sprout::move(tuple_impl());
+					return *this;
+				}
+				tuple_impl& operator=(sprout::tuples::detail::tuple_impl<Index>&& t) {
+					*this = sprout::move(tuple_impl());
+					return *this;
+				}
+			};
+
+			template<bool Head, bool... Tail>
+			struct and_impl;
+			template<>
+			struct and_impl<true>
+				: public std::true_type
+			{};
+			template<>
+			struct and_impl<false>
+				: public std::false_type
+			{};
+			template<bool... Tail>
+			struct and_impl<true, Tail...>
+				: public std::integral_constant<bool, sprout::tuples::detail::and_impl<Tail...>::value>
+			{};
+			template<bool... Tail>
+			struct and_impl<false, Tail...>
+				: public std::false_type
+			{};
+			template<typename... Types>
+			struct and_
+				: public sprout::tuples::detail::and_impl<Types::value...>
+			{};
+
+			template<bool Head, bool... Tail>
+			struct or_impl;
+			template<>
+			struct or_impl<true>
+				: public std::true_type
+			{};
+			template<>
+			struct or_impl<false>
+				: public std::false_type
+			{};
+			template<bool... Tail>
+			struct or_impl<true, Tail...>
+				: public std::true_type
+			{};
+			template<bool... Tail>
+			struct or_impl<false, Tail...>
+				: public std::integral_constant<bool, sprout::tuples::detail::or_impl<Tail...>::value>
+			{};
+			template<typename... Types>
+			struct or_
+				: public sprout::tuples::detail::and_impl<Types::value...>
+			{};
+		}	// namespace detail
+
+		//
+		// tuple
+		//
+		template<typename... Types>
+		class tuple
+			: public sprout::tuples::detail::tuple_impl<0, Types...>
+		{
+		public:
+			typedef sprout::tuples::detail::tuple_impl<0, Types...> inherited_type;
+		public:
+			// tuple construction
+			SPROUT_CONSTEXPR tuple()
+				: inherited_type()
+			{}
+			explicit SPROUT_CONSTEXPR tuple(Types const&... elements)
+				: inherited_type(elements...)
+			{}
+			template<
+				typename U,
+				typename = typename std::enable_if<
+					!sprout::tuples::is_tuple<typename std::remove_reference<U>::type>::value
+				>::type
+			>
+			explicit SPROUT_CONSTEXPR tuple(U&& elem)
+				: inherited_type(sprout::forward<U>(elem))
+			{}
+			template<
+				typename U1,
+				typename U2,
+				typename... UTypes
+			>
+			explicit SPROUT_CONSTEXPR tuple(U1&& elem1, U2&& elem2, UTypes&&... elements)
+				: inherited_type(sprout::forward<U1>(elem1), sprout::forward<U2>(elem2), sprout::forward<UTypes>(elements)...)
+			{}
+			SPROUT_CONSTEXPR tuple(tuple const&) = default;
+			SPROUT_CONSTEXPR tuple(tuple&&) = default;
+			template<typename... UTypes>
+			SPROUT_CONSTEXPR tuple(sprout::tuples::tuple<UTypes...> const& t)
+				: inherited_type(static_cast<sprout::tuples::detail::tuple_impl<0, UTypes...> const&>(t))
+			{}
+			template<typename... UTypes>
+			SPROUT_CONSTEXPR tuple(sprout::tuples::tuple<UTypes...>&& t)
+				: inherited_type(static_cast<sprout::tuples::detail::tuple_impl<0, UTypes...>&&>(t))
+			{}
+			// tuple assignment
+			tuple& operator=(tuple const& rhs) {
+				static_cast<inherited_type&>(*this) = rhs;
+				return *this;
+			}
+			tuple& operator=(tuple&& rhs) SPROUT_NOEXCEPT_EXPR(std::is_nothrow_move_assignable<inherited_type>::value) {
+				static_cast<inherited_type&>(*this) = sprout::move(rhs);
+				return *this;
+			}
+			template<typename... UTypes>
+			tuple& operator=(sprout::tuples::tuple<UTypes...> const& rhs) {
+				static_cast<inherited_type&>(*this) = rhs;
+				return *this;
+			}
+			template<typename... UTypes>
+			tuple& operator=(sprout::tuples::tuple<UTypes...>&& rhs) {
+				static_cast<inherited_type&>(*this) = sprout::move(rhs);
+				return *this;
+			}
+			// tuple swap
+			void swap(tuple& other) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(inherited_type::swap(other))) {
+				inherited_type::swap(other);
+			}
+		};
+		template<>
+		class tuple<> {
+		public:
+			// tuple swap
+			void swap(tuple&) SPROUT_NOEXCEPT {}
+		};
+
+		//
+		// swap
+		//
+		template<typename... Types>
+		inline void swap(
+			sprout::tuples::tuple<Types...>& lhs,
+			sprout::tuples::tuple<Types...>& rhs
+			) SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(lhs.swap(rhs)))
+		{
+			lhs.swap(rhs);
+		}
+
+		namespace detail {
+			template<std::size_t I, typename T>
+			struct tuple_element_impl;
+			template<typename Head, typename... Tail>
+			struct tuple_element_impl<0, sprout::tuples::tuple<Head, Tail...> > {
+			public:
+				typedef Head type;
+			};
+			template<std::size_t I, typename Head, typename... Tail>
+			struct tuple_element_impl<I, sprout::tuples::tuple<Head, Tail...> >
+				: public sprout::tuples::detail::tuple_element_impl<I - 1, sprout::tuples::tuple<Tail...> >
+			{};
+		}	// namespace detail
+	}	// namespace tuples
+
+	using sprout::tuples::tuple;
+	using sprout::tuples::swap;
+}	// namespace sprout
+
+namespace std {
+	//
+	// tuple_size
+	//
+	template<typename... Types>
+	struct tuple_size<sprout::tuples::tuple<Types...> >
+		: public std::integral_constant<std::size_t, sizeof...(Types)>
+	{};
+
+	//
+	// tuple_element
+	//
+	template<std::size_t I, typename... Types>
+	struct tuple_element<I, sprout::tuples::tuple<Types...> >
+		: public sprout::tuples::detail::tuple_element_impl<I, sprout::tuples::tuple<Types...> >
+	{};
+}	// namespace std
+
+#endif	// #ifndef SPROUT_TUPLE_TUPLE_TUPLE_HPP
diff --git a/sprout/tuple/tuple/tuple_fwd.hpp b/sprout/tuple/tuple/tuple_fwd.hpp
new file mode 100644
index 00000000..96480adb
--- /dev/null
+++ b/sprout/tuple/tuple/tuple_fwd.hpp
@@ -0,0 +1,13 @@
+#ifndef SPROUT_TUPLE_TUPLE_TUPLE_FWD_HPP
+#define SPROUT_TUPLE_TUPLE_TUPLE_FWD_HPP
+
+#include <sprout/config.hpp>
+
+namespace sprout {
+	namespace tuples {
+		template<typename... Types>
+		class tuple;
+	}	// namespace tuples
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TUPLE_TUPLE_TUPLE_FWD_HPP
diff --git a/sprout/tuple/tuple/type_traits.hpp b/sprout/tuple/tuple/type_traits.hpp
new file mode 100644
index 00000000..290b653b
--- /dev/null
+++ b/sprout/tuple/tuple/type_traits.hpp
@@ -0,0 +1,34 @@
+#ifndef SPROUT_TUPLE_TUPLE_TYPE_TRAITS_HPP
+#define SPROUT_TUPLE_TUPLE_TYPE_TRAITS_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/tuple/tuple/tuple_fwd.hpp>
+
+namespace sprout {
+	namespace tuples {
+		//
+		// is_tuple
+		//
+		template<typename T>
+		struct is_tuple
+			: public std::false_type
+		{};
+		template<typename T>
+		struct is_tuple<T const>
+			: public sprout::tuples::is_tuple<T>
+		{};
+		template<typename T>
+		struct is_tuple<T const volatile>
+			: public sprout::tuples::is_tuple<T>
+		{};
+		template<typename... Types>
+		struct is_tuple<sprout::tuples::tuple<Types...> >
+			: public std::true_type
+		{};
+	}	// namespace tuples
+
+	using sprout::tuples::is_tuple;
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TUPLE_TUPLE_TYPE_TRAITS_HPP
diff --git a/sprout/type/string.hpp b/sprout/type/string.hpp
index a3001631..0c1145d8 100644
--- a/sprout/type/string.hpp
+++ b/sprout/type/string.hpp
@@ -1,42 +1,7 @@
 #ifndef SPROUT_TYPE_STRING_HPP
 #define SPROUT_TYPE_STRING_HPP
 
-#include <cstddef>
-#include <tuple>
-#include <sprout/config.hpp>
-#include <sprout/type/tuple.hpp>
-#include <sprout/type/integral_array.hpp>
-
-namespace sprout {
-	namespace types {
-		//
-		// basic_string
-		//
-		template<typename T, T... Values>
-		struct basic_string
-			: public sprout::types::integral_array<T, Values...>
-		{};
-	}	// namespace types
-}	// namespace sprout
-
-namespace std {
-	//
-	// tuple_size
-	//
-	template<typename T, T... Values>
-	struct tuple_size<sprout::types::basic_string<T, Values...> >
-		: public std::tuple_size<sprout::types::integral_array<T, Values...> >
-	{};
-
-	//
-	// tuple_element
-	//
-	template<std::size_t I, typename T, T... Values>
-	struct tuple_element<I, sprout::types::basic_string<T, Values...> >
-		: public std::tuple_element<I, sprout::types::integral_array<T, Values...> >
-	{};
-}	// namespace std
-
+#include <sprout/type/string/string.hpp>
 #include <sprout/type/string/to_string_constant.hpp>
 #include <sprout/type/string/to_string.hpp>
 #include <sprout/type/string/alias.hpp>
diff --git a/sprout/type/string/alias.hpp b/sprout/type/string/alias.hpp
index 04e4863c..63f77d63 100644
--- a/sprout/type/string/alias.hpp
+++ b/sprout/type/string/alias.hpp
@@ -2,7 +2,7 @@
 #define SPROUT_TYPE_STRING_ALIAS_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/type/string.hpp>
+#include <sprout/type/string/string.hpp>
 
 #if SPROUT_USE_TEMPLATE_ALIASES
 
diff --git a/sprout/type/string/string.hpp b/sprout/type/string/string.hpp
new file mode 100644
index 00000000..7b8ac5d6
--- /dev/null
+++ b/sprout/type/string/string.hpp
@@ -0,0 +1,40 @@
+#ifndef SPROUT_TYPE_STRING_STRING_HPP
+#define SPROUT_TYPE_STRING_STRING_HPP
+
+#include <cstddef>
+#include <tuple>
+#include <sprout/config.hpp>
+#include <sprout/type/tuple.hpp>
+#include <sprout/type/integral_array.hpp>
+
+namespace sprout {
+	namespace types {
+		//
+		// basic_string
+		//
+		template<typename T, T... Values>
+		struct basic_string
+			: public sprout::types::integral_array<T, Values...>
+		{};
+	}	// namespace types
+}	// namespace sprout
+
+namespace std {
+	//
+	// tuple_size
+	//
+	template<typename T, T... Values>
+	struct tuple_size<sprout::types::basic_string<T, Values...> >
+		: public std::tuple_size<sprout::types::integral_array<T, Values...> >
+	{};
+
+	//
+	// tuple_element
+	//
+	template<std::size_t I, typename T, T... Values>
+	struct tuple_element<I, sprout::types::basic_string<T, Values...> >
+		: public std::tuple_element<I, sprout::types::integral_array<T, Values...> >
+	{};
+}	// namespace std
+
+#endif	// #ifndef SPROUT_TYPE_STRING_STRING_HPP
diff --git a/sprout/type/string/to_string.hpp b/sprout/type/string/to_string.hpp
index ed944459..d14570b8 100644
--- a/sprout/type/string/to_string.hpp
+++ b/sprout/type/string/to_string.hpp
@@ -5,7 +5,7 @@
 #include <type_traits>
 #include <sprout/config.hpp>
 #include <sprout/string.hpp>
-#include <sprout/type/string.hpp>
+#include <sprout/type/string/string.hpp>
 #include <sprout/index_tuple.hpp>
 #include <sprout/container/traits.hpp>
 #include <sprout/container/size.hpp>
diff --git a/sprout/type/string/to_string_constant.hpp b/sprout/type/string/to_string_constant.hpp
index 80791f60..cd7134c0 100644
--- a/sprout/type/string/to_string_constant.hpp
+++ b/sprout/type/string/to_string_constant.hpp
@@ -5,7 +5,7 @@
 #include <sprout/config.hpp>
 #include <sprout/index_tuple.hpp>
 #include <sprout/string.hpp>
-#include <sprout/type/string.hpp>
+#include <sprout/type/string/string.hpp>
 #include <sprout/type/tuple.hpp>
 #include <sprout/type/seq/algorithm/find_if.hpp>
 #include <sprout/type/iterator/distance.hpp>
diff --git a/sprout/uuid.hpp b/sprout/uuid.hpp
index b66a707d..dbca076b 100644
--- a/sprout/uuid.hpp
+++ b/sprout/uuid.hpp
@@ -3,10 +3,10 @@
 
 #include <sprout/config.hpp>
 #include <sprout/uuid/uuid.hpp>
-#include <sprout/uuid/uuid_io.hpp>
-#include <sprout/uuid/uuid_hash.hpp>
-#include <sprout/uuid/uuid_tuple.hpp>
-#include <sprout/uuid/uuid_generators.hpp>
+#include <sprout/uuid/io.hpp>
+#include <sprout/uuid/hash.hpp>
+#include <sprout/uuid/tuple.hpp>
+#include <sprout/uuid/generators.hpp>
 #include <sprout/uuid/udl.hpp>
 
 #endif	// #ifndef SPROUT_UUID_HPP
diff --git a/sprout/uuid/uuid_generators.hpp b/sprout/uuid/generators.hpp
similarity index 59%
rename from sprout/uuid/uuid_generators.hpp
rename to sprout/uuid/generators.hpp
index 8bd675e2..a3eed792 100644
--- a/sprout/uuid/uuid_generators.hpp
+++ b/sprout/uuid/generators.hpp
@@ -1,5 +1,5 @@
-#ifndef SPROUT_UUID_UUID_GENERATORS_HPP
-#define SPROUT_UUID_UUID_GENERATORS_HPP
+#ifndef SPROUT_UUID_GENERATORS_HPP
+#define SPROUT_UUID_GENERATORS_HPP
 
 #include <sprout/config.hpp>
 #include <sprout/uuid/nil_generator.hpp>
@@ -7,4 +7,4 @@
 #include <sprout/uuid/name_generator.hpp>
 #include <sprout/uuid/random_generator.hpp>
 
-#endif	// #ifndef SPROUT_UUID_UUID_GENERATORS_HPP
+#endif	// #ifndef SPROUT_UUID_GENERATORS_HPP
diff --git a/sprout/uuid/uuid_hash.hpp b/sprout/uuid/hash.hpp
similarity index 70%
rename from sprout/uuid/uuid_hash.hpp
rename to sprout/uuid/hash.hpp
index fff4ce5c..73c23a1f 100644
--- a/sprout/uuid/uuid_hash.hpp
+++ b/sprout/uuid/hash.hpp
@@ -1,5 +1,5 @@
-#ifndef SPROUT_UUID_UUID_HASH_HPP
-#define SPROUT_UUID_UUID_HASH_HPP
+#ifndef SPROUT_UUID_HASH_HPP
+#define SPROUT_UUID_HASH_HPP
 
 #include <cstddef>
 #include <sprout/config.hpp>
@@ -12,4 +12,4 @@ namespace sprout {
 	}
 }	// namespace sprout
 
-#endif	// #ifndef SPROUT_UUID_UUID_HASH_HPP
+#endif	// #ifndef SPROUT_UUID_HASH_HPP
diff --git a/sprout/uuid/uuid_io.hpp b/sprout/uuid/io.hpp
similarity index 95%
rename from sprout/uuid/uuid_io.hpp
rename to sprout/uuid/io.hpp
index 35fa446b..454aa2e2 100644
--- a/sprout/uuid/uuid_io.hpp
+++ b/sprout/uuid/io.hpp
@@ -1,5 +1,5 @@
-#ifndef SPROUT_UUID_UUID_IO_HPP
-#define SPROUT_UUID_UUID_IO_HPP
+#ifndef SPROUT_UUID_IO_HPP
+#define SPROUT_UUID_IO_HPP
 
 #include <cstddef>
 #include <algorithm>
@@ -181,4 +181,4 @@ namespace sprout {
 	}	// namespace uuids
 }	// namespace sprout
 
-#endif	// #ifndef SPROUT_UUID_UUID_IO_HPP
+#endif	// #ifndef SPROUT_UUID_IO_HPP
diff --git a/sprout/uuid/uuid_tuple.hpp b/sprout/uuid/tuple.hpp
similarity index 88%
rename from sprout/uuid/uuid_tuple.hpp
rename to sprout/uuid/tuple.hpp
index 7aee7043..40be87d9 100644
--- a/sprout/uuid/uuid_tuple.hpp
+++ b/sprout/uuid/tuple.hpp
@@ -1,5 +1,5 @@
-#ifndef SPROUT_UUID_UUID_TUPLE_HPP
-#define SPROUT_UUID_UUID_TUPLE_HPP
+#ifndef SPROUT_UUID_TUPLE_HPP
+#define SPROUT_UUID_TUPLE_HPP
 
 #include <cstddef>
 #include <tuple>
@@ -57,4 +57,4 @@ namespace std {
 	};
 }	// namespace std
 
-#endif	// #ifndef SPROUT_UUID_UUID_TUPLE_HPP
+#endif	// #ifndef SPROUT_UUID_TUPLE_HPP