diff --git a/libs/optional/test/optional.cpp b/libs/optional/test/optional.cpp
index abe89404..d2f0c3f3 100644
--- a/libs/optional/test/optional.cpp
+++ b/libs/optional/test/optional.cpp
@@ -304,7 +304,6 @@ namespace testspr {
 				TESTSPR_ASSERT(!opt3);
 			}
 
-
 			// get
 			TESTSPR_BOTH_ASSERT(sprout::get(opt1) == 1234);
 			{
diff --git a/libs/tuple/test/tuple.cpp b/libs/tuple/test/tuple.cpp
new file mode 100644
index 00000000..e6844d55
--- /dev/null
+++ b/libs/tuple/test/tuple.cpp
@@ -0,0 +1,235 @@
+#ifndef SPROUT_LIBS_TUPLE_TEST_TUPLE_CPP
+#define SPROUT_LIBS_TUPLE_TEST_TUPLE_CPP
+
+#include <sstream>
+#include <sprout/tuple/tuple.hpp>
+#include <testspr/tools.hpp>
+
+namespace testspr {
+	static void tuple_test() {
+		using namespace sprout;
+		{
+			SPROUT_STATIC_CONSTEXPR auto tup1 = sprout::tuples::tuple<int, double>(1, 1.0);
+			SPROUT_STATIC_CONSTEXPR auto tup2 = sprout::tuples::tuple<int, double>();
+
+			// constructor
+			{
+				SPROUT_STATIC_CONSTEXPR auto tup3 = sprout::tuples::tuple<int, double>();
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(tup3) == 0);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(tup3) == 0.0);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto tup3 = sprout::tuples::tuple<int, double>(tup1);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(tup3) == 1.0);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto tup3 = sprout::tuples::tuple<int, double>(1, 1.0);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(tup3) == 1.0);
+			}
+
+			{
+				SPROUT_STATIC_CONSTEXPR auto tup3 = sprout::tuples::tuple<int, double>(1l);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(tup3) == 0.0);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto tup3 = sprout::tuples::tuple<int, double>(1l, 1.0f);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(tup3) == 1.0);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto tup3 = sprout::tuples::tuple<int, double>(1l, 1.0f, '-');
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(tup3) == 1.0);
+			}
+
+			{
+				SPROUT_STATIC_CONSTEXPR auto tup3 = sprout::tuples::tuple<int, double>(sprout::tuples::tuple<long>(1l));
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(tup3) == 0.0);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto tup3 = sprout::tuples::tuple<int, double>(sprout::tuples::tuple<long, float>(1l, 1.0f));
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(tup3) == 1.0);
+			}
+			{
+				SPROUT_STATIC_CONSTEXPR auto tup3 = sprout::tuples::tuple<int, double>(sprout::tuples::tuple<long, float, char>(1l, 1.0f, '-'));
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(tup3) == 1.0);
+			}
+
+			// operator=
+			{
+				auto tup3 = tup2;
+				tup3 = sprout::tuples::tuple<int, double>(1, 1.0);
+				TESTSPR_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_ASSERT(sprout::tuples::get<1>(tup3) == 1.0);
+			}
+			{
+				auto tup3 = tup2;
+				tup3 = sprout::tuples::tuple<long>(1l);
+				TESTSPR_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_ASSERT(sprout::tuples::get<1>(tup3) == 0.0);
+			}
+			{
+				auto tup3 = tup2;
+				tup3 = sprout::tuples::tuple<long, float>(1l, 1.0f);
+				TESTSPR_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_ASSERT(sprout::tuples::get<1>(tup3) == 1.0);
+			}
+			{
+				auto tup3 = tup2;
+				tup3 = sprout::tuples::tuple<long, float, char>(1l, 1.0f, '-');
+				TESTSPR_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_ASSERT(sprout::tuples::get<1>(tup3) == 1.0);
+			}
+
+			// swap
+			{
+				auto tup3 = tup1;
+				auto tup4 = tup2;
+				tup3.swap(tup4);
+				TESTSPR_ASSERT(sprout::tuples::get<0>(tup3) == 0);
+				TESTSPR_ASSERT(sprout::tuples::get<1>(tup3) == 0.0);
+				TESTSPR_ASSERT(sprout::tuples::get<0>(tup4) == 1);
+				TESTSPR_ASSERT(sprout::tuples::get<1>(tup4) == 1.0);
+			}
+			{
+				auto tup3 = tup1;
+				auto tup4 = tup2;
+				swap(tup3, tup4);
+				TESTSPR_ASSERT(sprout::tuples::get<0>(tup3) == 0);
+				TESTSPR_ASSERT(sprout::tuples::get<1>(tup3) == 0.0);
+				TESTSPR_ASSERT(sprout::tuples::get<0>(tup4) == 1);
+				TESTSPR_ASSERT(sprout::tuples::get<1>(tup4) == 1.0);
+			}
+
+			// std::tuple_size
+			TESTSPR_BOTH_ASSERT(std::tuple_size<decltype(tup1)>::value == 2);
+
+			// std::tuple_element
+			TESTSPR_BOTH_ASSERT((std::is_same<std::tuple_element<0, decltype(tup1)>::type, int const>::value));
+			TESTSPR_BOTH_ASSERT((std::is_same<std::tuple_element<1, decltype(tup1)>::type, double const>::value));
+
+			// operator==
+			TESTSPR_BOTH_ASSERT(!(tup1 == tup2));
+			TESTSPR_BOTH_ASSERT((tup1 == sprout::tuples::tuple<int, double>(1, 1.0)));
+			TESTSPR_BOTH_ASSERT((!(tup1 == sprout::tuples::tuple<long, float>())));
+			TESTSPR_BOTH_ASSERT((tup1 == sprout::tuples::tuple<long, float>(1l, 1.0f)));
+
+			// operator!=
+			TESTSPR_BOTH_ASSERT(tup1 != tup2);
+			TESTSPR_BOTH_ASSERT((!(tup1 != sprout::tuples::tuple<int, double>(1, 1.0))));
+			TESTSPR_BOTH_ASSERT((tup1 != sprout::tuples::tuple<long, float>()));
+			TESTSPR_BOTH_ASSERT((!(tup1 != sprout::tuples::tuple<long, float>(1l, 1.0f))));
+
+			// operator<
+			TESTSPR_BOTH_ASSERT(!(tup1 < tup2));
+			TESTSPR_BOTH_ASSERT((!(tup1 < sprout::tuples::tuple<int, double>(1, -1.0))));
+			TESTSPR_BOTH_ASSERT((!(tup1 < sprout::tuples::tuple<int, double>(1, 1.0))));
+			TESTSPR_BOTH_ASSERT((tup1 < sprout::tuples::tuple<int, double>(1, 2.0)));
+			TESTSPR_BOTH_ASSERT((!(tup1 < sprout::tuples::tuple<long, float>())));
+			TESTSPR_BOTH_ASSERT((!(tup1 < sprout::tuples::tuple<long, float>(1l, -1.0f))));
+			TESTSPR_BOTH_ASSERT((!(tup1 < sprout::tuples::tuple<long, float>(1l, 1.0f))));
+			TESTSPR_BOTH_ASSERT((tup1 < sprout::tuples::tuple<long, float>(1l, 2.0f)));
+
+			// operator>
+			TESTSPR_BOTH_ASSERT(tup1 > tup2);
+			TESTSPR_BOTH_ASSERT((tup1 > sprout::tuples::tuple<int, double>(1, -1.0)));
+			TESTSPR_BOTH_ASSERT((!(tup1 > sprout::tuples::tuple<int, double>(1, 1.0))));
+			TESTSPR_BOTH_ASSERT((!(tup1 > sprout::tuples::tuple<int, double>(1, 2.0))));
+			TESTSPR_BOTH_ASSERT((tup1 > sprout::tuples::tuple<long, float>()));
+			TESTSPR_BOTH_ASSERT((tup1 > sprout::tuples::tuple<long, float>(1l, -1.0f)));
+			TESTSPR_BOTH_ASSERT((!(tup1 > sprout::tuples::tuple<long, float>(1l, 1.0f))));
+			TESTSPR_BOTH_ASSERT((!(tup1 > sprout::tuples::tuple<long, float>(1l, 2.0f))));
+
+			// operator<=
+			TESTSPR_BOTH_ASSERT(!(tup1 <= tup2));
+			TESTSPR_BOTH_ASSERT((!(tup1 <= sprout::tuples::tuple<int, double>(1, -1.0))));
+			TESTSPR_BOTH_ASSERT((tup1 <= sprout::tuples::tuple<int, double>(1, 1.0)));
+			TESTSPR_BOTH_ASSERT((tup1 <= sprout::tuples::tuple<int, double>(1, 2.0)));
+			TESTSPR_BOTH_ASSERT((!(tup1 <= sprout::tuples::tuple<long, float>())));
+			TESTSPR_BOTH_ASSERT((!(tup1 <= sprout::tuples::tuple<long, float>(1l, -1.0f))));
+			TESTSPR_BOTH_ASSERT((tup1 <= sprout::tuples::tuple<long, float>(1l, 1.0f)));
+			TESTSPR_BOTH_ASSERT((tup1 <= sprout::tuples::tuple<long, float>(1l, 2.0f)));
+
+			// operator>=
+			TESTSPR_BOTH_ASSERT(tup1 >= tup2);
+			TESTSPR_BOTH_ASSERT((tup1 >= sprout::tuples::tuple<int, double>(1, -1.0)));
+			TESTSPR_BOTH_ASSERT((tup1 >= sprout::tuples::tuple<int, double>(1, 1.0)));
+			TESTSPR_BOTH_ASSERT((!(tup1 >= sprout::tuples::tuple<int, double>(1, 2.0))));
+			TESTSPR_BOTH_ASSERT((tup1 >= sprout::tuples::tuple<long, float>()));
+			TESTSPR_BOTH_ASSERT((tup1 >= sprout::tuples::tuple<long, float>(1l, -1.0f)));
+			TESTSPR_BOTH_ASSERT((tup1 >= sprout::tuples::tuple<long, float>(1l, 1.0f)));
+			TESTSPR_BOTH_ASSERT((!(tup1 >= sprout::tuples::tuple<long, float>(1l, 2.0f))));
+
+			// get
+			TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(tup1) == 1);
+			TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(tup1) == 1.0);
+			{
+				auto tup3 = tup1;
+				TESTSPR_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_ASSERT(sprout::tuples::get<1>(tup3) == 1.0);
+			}
+
+			// tuple_size
+			TESTSPR_BOTH_ASSERT(sprout::tuples::tuple_size<decltype(tup1)>::value == 2);
+
+			// tuple_element
+			TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<0, decltype(tup1)>::type, int const>::value));
+			TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<1, decltype(tup1)>::type, double const>::value));
+
+			// make_tuple
+			TESTSPR_BOTH_ASSERT(sprout::tuples::make_tuple(1, 1.0) == tup1);
+
+			// forward_as_tuple
+			TESTSPR_BOTH_ASSERT(sprout::tuples::forward_as_tuple(1, 1.0) == tup1);
+
+			// tie
+			{
+				auto v1 = 0;
+				auto v2 = 0.0;
+				TESTSPR_ASSERT(sprout::tuples::tie(v1, v2) == tup2);
+
+				sprout::tuples::tie(v1, v2) = tup1;
+				TESTSPR_ASSERT(v1 == 1);
+				TESTSPR_ASSERT(v2 == 1.0);
+			}
+
+			// tuple_cat
+			{
+				typedef sprout::tuples::result_of::tuple_cat<decltype(tup1), decltype(tup2)>::type concatenated_type;
+				TESTSPR_BOTH_ASSERT(sprout::tuples::tuple_size<concatenated_type>::value == 4);
+				TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<0, concatenated_type>::type, int>::value));
+				TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<1, concatenated_type>::type, double>::value));
+				TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<2, concatenated_type>::type, int>::value));
+				TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<3, concatenated_type>::type, double>::value));
+			}
+
+			{
+				SPROUT_STATIC_CONSTEXPR auto tup3 = sprout::tuples::tuple_cat(tup1, tup2);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(tup3) == 1);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(tup3) == 1.0);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<2>(tup3) == 0);
+				TESTSPR_BOTH_ASSERT(sprout::tuples::get<3>(tup3) == 0.0);
+			}
+
+			// is_tuple
+			TESTSPR_BOTH_ASSERT(sprout::tuples::is_tuple<decltype(tup1)>::value);
+			TESTSPR_BOTH_ASSERT(!sprout::tuples::is_tuple<int>::value);
+
+			// hash_value
+			TESTSPR_BOTH_ASSERT((sprout::hash_value(sprout::tuples::tuple<int, int>(1, 2)) != 0));
+		}
+	}
+}	// namespace testspr
+
+#ifndef TESTSPR_CPP_INCLUDE
+#	define TESTSPR_TEST_FUNCTION testspr::tuple_test
+#	include <testspr/include_main.hpp>
+#endif
+
+#endif	// #ifndef SPROUT_LIBS_TUPLE_TEST_TUPLE_CPP
diff --git a/sprout/tuple/tuple.hpp b/sprout/tuple/tuple.hpp
index 86316466..337fac46 100644
--- a/sprout/tuple/tuple.hpp
+++ b/sprout/tuple/tuple.hpp
@@ -4,10 +4,10 @@
 #include <sprout/config.hpp>
 #include <sprout/tuple/tuple/tuple_fwd.hpp>
 #include <sprout/tuple/tuple/tuple.hpp>
+#include <sprout/tuple/tuple/comparison.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>
 #include <sprout/tuple/tuple/hash.hpp>
 
diff --git a/sprout/tuple/tuple/get.hpp b/sprout/tuple/tuple/get.hpp
index 75efddb6..674ecafe 100644
--- a/sprout/tuple/tuple/get.hpp
+++ b/sprout/tuple/tuple/get.hpp
@@ -40,17 +40,26 @@ namespace sprout {
 			: 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>
-		{};
+		struct tuple_element<I, T const> {
+		public:
+			typedef typename std::add_const<
+				typename sprout::tuples::tuple_element<I, T>::type
+			>::type type;
+		};
 		template<std::size_t I, typename T>
-		struct tuple_element<I, T volatile>
-			: public sprout::tuples::tuple_element<I, T>
-		{};
+		struct tuple_element<I, T volatile> {
+		public:
+			typedef typename std::add_volatile<
+				typename sprout::tuples::tuple_element<I, T>::type
+			>::type type;
+		};
 		template<std::size_t I, typename T>
-		struct tuple_element<I, T const volatile>
-			: public sprout::tuples::tuple_element<I, T>
-		{};
+		struct tuple_element<I, T const volatile> {
+		public:
+			typedef typename std::add_cv<
+				typename sprout::tuples::tuple_element<I, T>::type
+			>::type type;
+		};
 
 		namespace detail {
 			template<std::size_t I, typename Head, typename... Tail>
diff --git a/sprout/tuple/tuple/make_tuple.hpp b/sprout/tuple/tuple/make_tuple.hpp
index 30f2491e..7dd9b1dd 100644
--- a/sprout/tuple/tuple/make_tuple.hpp
+++ b/sprout/tuple/tuple/make_tuple.hpp
@@ -14,7 +14,8 @@ namespace sprout {
 		// make_tuple
 		//
 		template<typename... Types>
-		inline SPROUT_CONSTEXPR sprout::tuples::tuple<typename std::decay<Types>::type...> make_tuple(Types&&... args) {
+		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)...);
 		}
 
@@ -22,7 +23,8 @@ namespace sprout {
 		// forward_as_tuple
 		//
 		template<typename... Types>
-		inline SPROUT_CONSTEXPR sprout::tuples::tuple<Types&&...> forward_as_tuple(Types&&... args) SPROUT_NOEXCEPT {
+		inline SPROUT_CONSTEXPR sprout::tuples::tuple<Types&&...>
+		forward_as_tuple(Types&&... args) SPROUT_NOEXCEPT {
 			return sprout::tuples::tuple<Types&&...>(sprout::forward<Types>(args)...);
 		}
 
@@ -30,7 +32,8 @@ namespace sprout {
 		// tie
 		//
 		template<typename... Types>
-		inline sprout::tuples::tuple<Types&...> tie(Types&... args) SPROUT_NOEXCEPT {
+		inline sprout::tuples::tuple<Types&...>
+		tie(Types&... args) SPROUT_NOEXCEPT {
 			return sprout::tuples::tuple<Types&...>(args...);
 		}
 
@@ -86,7 +89,7 @@ namespace sprout {
 			template<typename... Tuples>
 			struct tuple_cat
 				: public sprout::tuples::result_of::detail::tuple_cat_impl<
-					typename std::remove_reference<Tuples>::type...
+					typename std::decay<Tuples>::type...
 				>
 			{};
 		}	// namespace result_of
@@ -109,23 +112,6 @@ namespace sprout {
 
 			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:
@@ -135,6 +121,22 @@ namespace sprout {
 					return Result(sprout::forward<Args>(args)...);
 				}
 			};
+			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 T, typename... Args>
+				static SPROUT_CONSTEXPR Result
+				call(T&& t, Args&&... args) {
+					return sprout::tuples::detail::tuple_cat_impl<
+						Result,
+						typename sprout::tuples::detail::tuple_cat_1st_indexes<Tail...>::type,
+						Tail...
+					>::call(
+						sprout::forward<Args>(args)...,
+						sprout::tuples::get<Indexes>(sprout::forward<T>(t))...
+						);
+				}
+			};
 		}	// namespace detail
 		//
 		// tuple_cat
diff --git a/sprout/tuple/tuple/tuple.hpp b/sprout/tuple/tuple/tuple.hpp
index b7d0271d..2b003497 100644
--- a/sprout/tuple/tuple/tuple.hpp
+++ b/sprout/tuple/tuple/tuple.hpp
@@ -93,6 +93,8 @@ namespace sprout {
 			template<std::size_t Index>
 			class tuple_impl<Index> {
 			public:
+				template<typename...>
+				friend class tuple;
 				template<std::size_t, typename...>
 				friend class sprout::tuples::detail::tuple_impl;
 			protected:
@@ -124,6 +126,8 @@ namespace sprout {
 				, private sprout::tuples::detail::head_base<Index, Head, std::is_empty<Head>::value>
 			{
 			public:
+				template<typename...>
+				friend class tuple;
 				template<std::size_t, typename...>
 				friend class sprout::tuples::detail::tuple_impl;
 			public:
@@ -142,11 +146,11 @@ namespace sprout {
 				static SPROUT_CONSTEXPR inherited_type const& tail(tuple_impl const& t) SPROUT_NOEXCEPT {
 					return t;
 				}
-			protected:
+			public:
 				void swap(tuple_impl& t)
 				SPROUT_NOEXCEPT_EXPR(
-					SPROUT_NOEXCEPT_EXPR(sprout::swap(head(std::declval<Head&>()), head(t)))
-					&& SPROUT_NOEXCEPT_EXPR(inherited_type::swap(tail(t)))
+					SPROUT_NOEXCEPT_EXPR(sprout::swap(head(std::declval<tuple_impl&>()), head(t)))
+					&& SPROUT_NOEXCEPT_EXPR(std::declval<inherited_type&>().swap(tail(t)))
 					)
 				{
 					sprout::swap(head(*this), head(t));
@@ -223,52 +227,6 @@ namespace sprout {
 					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
 
 		//
@@ -278,7 +236,7 @@ namespace sprout {
 		class tuple
 			: public sprout::tuples::detail::tuple_impl<0, Types...>
 		{
-		public:
+		private:
 			typedef sprout::tuples::detail::tuple_impl<0, Types...> inherited_type;
 		public:
 			// tuple construction
@@ -338,7 +296,7 @@ namespace sprout {
 			}
 			// tuple swap
 			void swap(tuple& other)
-			SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(inherited_type::swap(other)))
+			SPROUT_NOEXCEPT_EXPR(SPROUT_NOEXCEPT_EXPR(std::declval<inherited_type&>().swap(other)))
 			{
 				inherited_type::swap(other);
 			}
diff --git a/testspr/print.hpp b/testspr/print.hpp
index c4f516eb..7e7666ad 100644
--- a/testspr/print.hpp
+++ b/testspr/print.hpp
@@ -46,6 +46,14 @@ namespace testspr {
 		testspr::print_ln(testspr::typename_of<T>());
 	}
 
+	//
+	// print_type
+	//
+	template<typename T>
+	void print_type() {
+		testspr::print_typename<testspr::id<T> >();
+	}
+
 	//
 	// print_hl
 	//
diff --git a/testspr/sprout.cpp b/testspr/sprout.cpp
index 57639832..ca5e9baa 100644
--- a/testspr/sprout.cpp
+++ b/testspr/sprout.cpp
@@ -9,6 +9,7 @@
 #include "../libs/array/test/array.cpp"
 #include "../libs/string/test/string.cpp"
 #include "../libs/bitset/test/bitset.cpp"
+#include "../libs/tuple/test/tuple.cpp"
 #include "../libs/optional/test/optional.cpp"
 #include "../libs/algorithm/test/algorithm.cpp"
 #include "../libs/random/test/random.cpp"
@@ -22,6 +23,7 @@ namespace testspr {
 		testspr::array_test();
 		testspr::string_test();
 		testspr::bitset_test();
+		testspr::tuple_test();
 		testspr::optional_test();
 		testspr::algorithm_test();
 		testspr::random_test();
diff --git a/testspr/tools.hpp b/testspr/tools.hpp
index e6e71663..3670c92d 100644
--- a/testspr/tools.hpp
+++ b/testspr/tools.hpp
@@ -45,6 +45,15 @@
 #endif	// #ifndef SPROUT_CONFIG_DISABLE_CONSTEXPR
 
 namespace testspr {
+	//
+	// do_nothing
+	//
+	template<typename T>
+	inline SPROUT_CONSTEXPR bool
+	do_nothing(T const&) SPROUT_NOEXCEPT {
+		return true;
+	}
+
 	//
 	// is_even
 	//
@@ -226,7 +235,7 @@ namespace testspr {
 	// distance
 	//
 	template<typename InputIterator>
-	SPROUT_CONSTEXPR typename std::iterator_traits<InputIterator>::difference_type
+	inline SPROUT_CONSTEXPR typename std::iterator_traits<InputIterator>::difference_type
 	distance(InputIterator first, InputIterator last) {
 		return first == last ? 0
 			: 1 + testspr::distance(first + 1, last)
@@ -246,7 +255,7 @@ namespace testspr {
 			;
 	}
 	template<typename Range1, typename Range2>
-	SPROUT_CONSTEXPR bool
+	inline SPROUT_CONSTEXPR bool
 	equal(Range1 const& range1, Range2 const& range2) {
 		return testspr::equal(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2));
 	}
@@ -255,7 +264,7 @@ namespace testspr {
 	// is_found
 	//
 	template<class InputIterator, typename T>
-	SPROUT_CONSTEXPR bool
+	inline SPROUT_CONSTEXPR bool
 	is_found(InputIterator first, InputIterator last, T const& value) {
 		return first == last ? false
 			: *first == value ? true
@@ -263,7 +272,7 @@ namespace testspr {
 			;
 	}
 	template<typename Range, typename T>
-	SPROUT_CONSTEXPR bool
+	inline SPROUT_CONSTEXPR bool
 	is_found(Range const& range, T const& value) {
 		return testspr::is_found(sprout::begin(range), sprout::end(range), value);
 	}
@@ -272,21 +281,21 @@ namespace testspr {
 	// count
 	//
 	template<typename InputIterator, typename T>
-	SPROUT_CONSTEXPR typename std::iterator_traits<InputIterator>::difference_type
+	inline SPROUT_CONSTEXPR typename std::iterator_traits<InputIterator>::difference_type
 	count(InputIterator first, InputIterator last, T const& value) {
 		return first == last ? 0
 			: (*first == value ? 1 : 0) + testspr::count(first + 1, last, value)
 			;
 	}
 	template<typename Range, typename T>
-	SPROUT_CONSTEXPR typename std::iterator_traits<typename Range::const_iterator>::difference_type
+	inline SPROUT_CONSTEXPR typename std::iterator_traits<typename Range::const_iterator>::difference_type
 	count(Range const& range, T const& value) {
 		return testspr::count(sprout::begin(range), sprout::end(range), value);
 	}
 
 	namespace detail {
 		template<typename ForwardIterator1, typename ForwardIterator2>
-		SPROUT_CONSTEXPR bool
+		inline SPROUT_CONSTEXPR bool
 		is_permutation_impl(
 			ForwardIterator1 first1, ForwardIterator1 last1,
 			ForwardIterator2 first2, ForwardIterator2 last2,
@@ -304,7 +313,7 @@ namespace testspr {
 	// is_permutation
 	//
 	template<typename ForwardIterator1, typename ForwardIterator2>
-	SPROUT_CONSTEXPR bool
+	inline SPROUT_CONSTEXPR bool
 	is_permutation(
 		ForwardIterator1 first1, ForwardIterator1 last1,
 		ForwardIterator2 first2, ForwardIterator2 last2
@@ -313,7 +322,7 @@ namespace testspr {
 		return testspr::detail::is_permutation_impl(first1, last1, first2, last2, first1, first2);
 	}
 	template<typename Range1, typename Range2>
-	SPROUT_CONSTEXPR bool
+	inline SPROUT_CONSTEXPR bool
 	is_permutation(Range1 const& range1, Range2 const& range2) {
 		return testspr::is_permutation(
 			sprout::begin(range1), sprout::end(range1),
diff --git a/testspr/typeinfo.hpp b/testspr/typeinfo.hpp
index e7f3537a..33996f8a 100644
--- a/testspr/typeinfo.hpp
+++ b/testspr/typeinfo.hpp
@@ -11,6 +11,15 @@
 #endif
 
 namespace testspr {
+	//
+	// id
+	//
+	template<typename T>
+	struct id {
+	public:
+		typedef T type;
+	};
+
 	//
 	// typename_of
 	//