From 2614c4e3f9d510f04a69a278d5016919a080bba6 Mon Sep 17 00:00:00 2001
From: bolero-MURAKAMI <bolero.murakami@gmail.com>
Date: Fri, 15 Sep 2017 19:08:49 +0900
Subject: [PATCH] add type tuple algorithms and C++17 type traits

---
 sprout/type/algorithm.hpp                     |   8 +
 sprout/type/algorithm/all_of.hpp              |  80 +++++++
 sprout/type/algorithm/all_of_same.hpp         |  79 ++++++
 sprout/type/algorithm/any_of.hpp              |  80 +++++++
 sprout/type/algorithm/any_of_same.hpp         |  79 ++++++
 sprout/type/algorithm/contains.hpp            |   4 +-
 sprout/type/algorithm/contains_if.hpp         |   4 +-
 sprout/type/algorithm/none_of.hpp             |  80 +++++++
 sprout/type/algorithm/none_of_same.hpp        |  79 ++++++
 sprout/type/algorithm/one_of.hpp              | 115 +++++++++
 sprout/type/algorithm/one_of_same.hpp         | 114 +++++++++
 .../has_unique_object_representations.hpp     |  41 ++++
 sprout/type_traits/invoke_result.hpp          |  29 +++
 sprout/type_traits/is_aggregate.hpp           |  41 ++++
 sprout/type_traits/property.hpp               |   2 +
 sprout/type_traits/result_of.hpp              | 224 +++---------------
 sprout/type_traits/transformation.hpp         |   1 +
 tools/darkroom/darkcult.sh                    |  26 +-
 tools/testspr/test.sh                         |   2 +-
 19 files changed, 883 insertions(+), 205 deletions(-)
 create mode 100644 sprout/type/algorithm/all_of.hpp
 create mode 100644 sprout/type/algorithm/all_of_same.hpp
 create mode 100644 sprout/type/algorithm/any_of.hpp
 create mode 100644 sprout/type/algorithm/any_of_same.hpp
 create mode 100644 sprout/type/algorithm/none_of.hpp
 create mode 100644 sprout/type/algorithm/none_of_same.hpp
 create mode 100644 sprout/type/algorithm/one_of.hpp
 create mode 100644 sprout/type/algorithm/one_of_same.hpp
 create mode 100644 sprout/type_traits/has_unique_object_representations.hpp
 create mode 100644 sprout/type_traits/invoke_result.hpp
 create mode 100644 sprout/type_traits/is_aggregate.hpp

diff --git a/sprout/type/algorithm.hpp b/sprout/type/algorithm.hpp
index 0470525b..e1cb7f78 100644
--- a/sprout/type/algorithm.hpp
+++ b/sprout/type/algorithm.hpp
@@ -9,6 +9,14 @@
 #define SPROUT_TYPE_ALGORITHM_HPP
 
 #include <sprout/config.hpp>
+#include <sprout/type/algorithm/all_of.hpp>
+#include <sprout/type/algorithm/all_of_same.hpp>
+#include <sprout/type/algorithm/any_of.hpp>
+#include <sprout/type/algorithm/any_of_same.hpp>
+#include <sprout/type/algorithm/none_of.hpp>
+#include <sprout/type/algorithm/none_of_same.hpp>
+#include <sprout/type/algorithm/one_of.hpp>
+#include <sprout/type/algorithm/one_of_same.hpp>
 #include <sprout/type/algorithm/find_index.hpp>
 #include <sprout/type/algorithm/find_index_if.hpp>
 #include <sprout/type/algorithm/count.hpp>
diff --git a/sprout/type/algorithm/all_of.hpp b/sprout/type/algorithm/all_of.hpp
new file mode 100644
index 00000000..e30c05a7
--- /dev/null
+++ b/sprout/type/algorithm/all_of.hpp
@@ -0,0 +1,80 @@
+/*=============================================================================
+  Copyright (c) 2011-2017 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_ALGORITHM_ALL_OF_HPP
+#define SPROUT_TYPE_ALGORITHM_ALL_OF_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/workaround/std/cstddef.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type/apply.hpp>
+#include <sprout/type/tuple.hpp>
+
+namespace sprout {
+	namespace types {
+		namespace detail {
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot,
+				bool C1 = (Pivot == 0)
+			>
+			struct all_of_impl;
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct all_of_impl<Tuple, Predicate, First, Last, Pivot, true>
+				: public sprout::bool_constant<
+					sprout::types::apply<Predicate, typename sprout::types::tuple_element<First, Tuple>::type>::type::value
+				>
+			{};
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct all_of_impl<Tuple, Predicate, First, Last, Pivot, false>
+				: public sprout::bool_constant<
+					sprout::types::detail::all_of_impl<
+						Tuple, Predicate, First, First + Pivot,
+						Pivot / 2
+					>::value
+					&& sprout::types::detail::all_of_impl<
+						Tuple, Predicate, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+				>
+			{};
+			template<typename Tuple, typename Predicate, std::size_t Size = sprout::types::tuple_size<Tuple>::value>
+			struct all_of
+				: public sprout::types::detail::all_of_impl<Tuple, Predicate, 0, Size, Size / 2>
+			{};
+			template<typename Tuple, typename Predicate>
+			struct all_of<Tuple, Predicate, 0>
+				: public sprout::true_type
+			{};
+		}	// namespace detail
+		//
+		// all_of
+		//
+		template<typename Tuple, typename Predicate>
+		struct all_of
+			: public sprout::types::detail::all_of<Tuple, Predicate>
+		{};
+
+#if SPROUT_USE_TEMPLATE_ALIASES
+		template<typename Tuple, typename Predicate>
+		using all_of_t = typename sprout::types::all_of<Tuple, Predicate>::type;
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
+
+#if SPROUT_USE_VARIABLE_TEMPLATES
+		template<typename Tuple, typename Predicate>
+		SPROUT_STATIC_CONSTEXPR bool all_of_v = sprout::types::all_of<Tuple, Predicate>::value;
+#endif	// #if SPROUT_USE_VARIABLE_TEMPLATES
+	}	// namespace types
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_ALGORITHM_ALL_OF_HPP
diff --git a/sprout/type/algorithm/all_of_same.hpp b/sprout/type/algorithm/all_of_same.hpp
new file mode 100644
index 00000000..5d6abc96
--- /dev/null
+++ b/sprout/type/algorithm/all_of_same.hpp
@@ -0,0 +1,79 @@
+/*=============================================================================
+  Copyright (c) 2011-2017 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_ALGORITHM_ALL_OF_SAME_HPP
+#define SPROUT_TYPE_ALGORITHM_ALL_OF_SAME_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/workaround/std/cstddef.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type/tuple.hpp>
+
+namespace sprout {
+	namespace types {
+		namespace detail {
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot,
+				bool C1 = (Pivot == 0)
+			>
+			struct all_of_same_impl;
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct all_of_same_impl<Tuple, T, First, Last, Pivot, true>
+				: public sprout::bool_constant<
+					std::is_same<typename sprout::types::tuple_element<First, Tuple>::type, T>::value
+				>
+			{};
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct all_of_same_impl<Tuple, T, First, Last, Pivot, false>
+				: public sprout::bool_constant<
+					sprout::types::detail::all_of_same_impl<
+						Tuple, T, First, First + Pivot,
+						Pivot / 2
+					>::value
+					&& sprout::types::detail::all_of_same_impl<
+						Tuple, T, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+				>
+			{};
+			template<typename Tuple, typename T, std::size_t Size = sprout::types::tuple_size<Tuple>::value>
+			struct all_of_same
+				: public sprout::types::detail::all_of_same_impl<Tuple, T, 0, Size, Size / 2>
+			{};
+			template<typename Tuple, typename T>
+			struct all_of_same<Tuple, T, 0>
+				: public sprout::true_type
+			{};
+		}	// namespace detail
+		//
+		// all_of_same
+		//
+		template<typename Tuple, typename T>
+		struct all_of_same
+			: public sprout::types::detail::all_of_same<Tuple, T>
+		{};
+
+#if SPROUT_USE_TEMPLATE_ALIASES
+		template<typename Tuple, typename T>
+		using all_of_same_t = typename sprout::types::all_of_same<Tuple, T>::type;
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
+
+#if SPROUT_USE_VARIABLE_TEMPLATES
+		template<typename Tuple, typename T>
+		SPROUT_STATIC_CONSTEXPR bool all_of_same_v = sprout::types::all_of_same<Tuple, T>::value;
+#endif	// #if SPROUT_USE_VARIABLE_TEMPLATES
+	}	// namespace types
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_ALGORITHM_ALL_OF_SAME_HPP
diff --git a/sprout/type/algorithm/any_of.hpp b/sprout/type/algorithm/any_of.hpp
new file mode 100644
index 00000000..3db6bd84
--- /dev/null
+++ b/sprout/type/algorithm/any_of.hpp
@@ -0,0 +1,80 @@
+/*=============================================================================
+  Copyright (c) 2011-2017 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_ALGORITHM_ANY_OF_HPP
+#define SPROUT_TYPE_ALGORITHM_ANY_OF_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/workaround/std/cstddef.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type/apply.hpp>
+#include <sprout/type/tuple.hpp>
+
+namespace sprout {
+	namespace types {
+		namespace detail {
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot,
+				bool C1 = (Pivot == 0)
+			>
+			struct any_of_impl;
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct any_of_impl<Tuple, Predicate, First, Last, Pivot, true>
+				: public sprout::bool_constant<
+					sprout::types::apply<Predicate, typename sprout::types::tuple_element<First, Tuple>::type>::type::value
+				>
+			{};
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct any_of_impl<Tuple, Predicate, First, Last, Pivot, false>
+				: public sprout::bool_constant<
+					sprout::types::detail::any_of_impl<
+						Tuple, Predicate, First, First + Pivot,
+						Pivot / 2
+					>::value
+					|| sprout::types::detail::any_of_impl<
+						Tuple, Predicate, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+				>
+			{};
+			template<typename Tuple, typename Predicate, std::size_t Size = sprout::types::tuple_size<Tuple>::value>
+			struct any_of
+				: public sprout::types::detail::any_of_impl<Tuple, Predicate, 0, Size, Size / 2>
+			{};
+			template<typename Tuple, typename Predicate>
+			struct any_of<Tuple, Predicate, 0>
+				: public sprout::false_type
+			{};
+		}	// namespace detail
+		//
+		// any_of
+		//
+		template<typename Tuple, typename Predicate>
+		struct any_of
+			: public sprout::types::detail::any_of<Tuple, Predicate>
+		{};
+
+#if SPROUT_USE_TEMPLATE_ALIASES
+		template<typename Tuple, typename Predicate>
+		using any_of_t = typename sprout::types::any_of<Tuple, Predicate>::type;
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
+
+#if SPROUT_USE_VARIABLE_TEMPLATES
+		template<typename Tuple, typename Predicate>
+		SPROUT_STATIC_CONSTEXPR bool any_of_v = sprout::types::any_of<Tuple, Predicate>::value;
+#endif	// #if SPROUT_USE_VARIABLE_TEMPLATES
+	}	// namespace types
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_ALGORITHM_ANY_OF_HPP
diff --git a/sprout/type/algorithm/any_of_same.hpp b/sprout/type/algorithm/any_of_same.hpp
new file mode 100644
index 00000000..444759bc
--- /dev/null
+++ b/sprout/type/algorithm/any_of_same.hpp
@@ -0,0 +1,79 @@
+/*=============================================================================
+  Copyright (c) 2011-2017 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_ALGORITHM_ANY_OF_SAME_HPP
+#define SPROUT_TYPE_ALGORITHM_ANY_OF_SAME_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/workaround/std/cstddef.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type/tuple.hpp>
+
+namespace sprout {
+	namespace types {
+		namespace detail {
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot,
+				bool C1 = (Pivot == 0)
+			>
+			struct any_of_same_impl;
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct any_of_same_impl<Tuple, T, First, Last, Pivot, true>
+				: public sprout::bool_constant<
+					std::is_same<typename sprout::types::tuple_element<First, Tuple>::type, T>::value
+				>
+			{};
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct any_of_same_impl<Tuple, T, First, Last, Pivot, false>
+				: public sprout::bool_constant<
+					sprout::types::detail::any_of_same_impl<
+						Tuple, T, First, First + Pivot,
+						Pivot / 2
+					>::value
+					|| sprout::types::detail::any_of_same_impl<
+						Tuple, T, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+				>
+			{};
+			template<typename Tuple, typename T, std::size_t Size = sprout::types::tuple_size<Tuple>::value>
+			struct any_of_same
+				: public sprout::types::detail::any_of_same_impl<Tuple, T, 0, Size, Size / 2>
+			{};
+			template<typename Tuple, typename T>
+			struct any_of_same<Tuple, T, 0>
+				: public sprout::false_type
+			{};
+		}	// namespace detail
+		//
+		// any_of_same
+		//
+		template<typename Tuple, typename T>
+		struct any_of_same
+			: public sprout::types::detail::any_of_same<Tuple, T>
+		{};
+
+#if SPROUT_USE_TEMPLATE_ALIASES
+		template<typename Tuple, typename T>
+		using any_of_same_t = typename sprout::types::any_of_same<Tuple, T>::type;
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
+
+#if SPROUT_USE_VARIABLE_TEMPLATES
+		template<typename Tuple, typename T>
+		SPROUT_STATIC_CONSTEXPR bool any_of_same_v = sprout::types::any_of_same<Tuple, T>::value;
+#endif	// #if SPROUT_USE_VARIABLE_TEMPLATES
+	}	// namespace types
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_ALGORITHM_ANY_OF_SAME_HPP
diff --git a/sprout/type/algorithm/contains.hpp b/sprout/type/algorithm/contains.hpp
index a8943923..919dd325 100644
--- a/sprout/type/algorithm/contains.hpp
+++ b/sprout/type/algorithm/contains.hpp
@@ -10,7 +10,7 @@
 
 #include <sprout/config.hpp>
 #include <sprout/type/tuple.hpp>
-#include <sprout/type/algorithm/find_index.hpp>
+#include <sprout/type/algorithm/any_of_same.hpp>
 
 namespace sprout {
 	namespace types {
@@ -19,7 +19,7 @@ namespace sprout {
 		//
 		template<typename Tuple, typename T>
 		struct contains
-			: public sprout::types::find_index<Tuple, T>::is_found
+			: public sprout::types::any_of_same<Tuple, T>
 		{};
 
 #if SPROUT_USE_TEMPLATE_ALIASES
diff --git a/sprout/type/algorithm/contains_if.hpp b/sprout/type/algorithm/contains_if.hpp
index af17229d..a2040357 100644
--- a/sprout/type/algorithm/contains_if.hpp
+++ b/sprout/type/algorithm/contains_if.hpp
@@ -10,7 +10,7 @@
 
 #include <sprout/config.hpp>
 #include <sprout/type/tuple.hpp>
-#include <sprout/type/algorithm/find_index_if.hpp>
+#include <sprout/type/algorithm/any_of.hpp>
 
 namespace sprout {
 	namespace types {
@@ -19,7 +19,7 @@ namespace sprout {
 		//
 		template<typename Tuple, typename Predicate>
 		struct contains_if
-			: public sprout::types::find_index_if<Tuple, Predicate>::is_found
+			: public sprout::types::any_of<Tuple, Predicate>
 		{};
 
 #if SPROUT_USE_TEMPLATE_ALIASES
diff --git a/sprout/type/algorithm/none_of.hpp b/sprout/type/algorithm/none_of.hpp
new file mode 100644
index 00000000..2ff0fa61
--- /dev/null
+++ b/sprout/type/algorithm/none_of.hpp
@@ -0,0 +1,80 @@
+/*=============================================================================
+  Copyright (c) 2011-2017 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_ALGORITHM_NONE_OF_HPP
+#define SPROUT_TYPE_ALGORITHM_NONE_OF_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/workaround/std/cstddef.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type/apply.hpp>
+#include <sprout/type/tuple.hpp>
+
+namespace sprout {
+	namespace types {
+		namespace detail {
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot,
+				bool C1 = (Pivot == 0)
+			>
+			struct none_of_impl;
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct none_of_impl<Tuple, Predicate, First, Last, Pivot, true>
+				: public sprout::bool_constant<
+					!sprout::types::apply<Predicate, typename sprout::types::tuple_element<First, Tuple>::type>::type::value
+				>
+			{};
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct none_of_impl<Tuple, Predicate, First, Last, Pivot, false>
+				: public sprout::bool_constant<
+					sprout::types::detail::none_of_impl<
+						Tuple, Predicate, First, First + Pivot,
+						Pivot / 2
+					>::value
+					&& sprout::types::detail::none_of_impl<
+						Tuple, Predicate, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+				>
+			{};
+			template<typename Tuple, typename Predicate, std::size_t Size = sprout::types::tuple_size<Tuple>::value>
+			struct none_of
+				: public sprout::types::detail::none_of_impl<Tuple, Predicate, 0, Size, Size / 2>
+			{};
+			template<typename Tuple, typename Predicate>
+			struct none_of<Tuple, Predicate, 0>
+				: public sprout::true_type
+			{};
+		}	// namespace detail
+		//
+		// none_of
+		//
+		template<typename Tuple, typename Predicate>
+		struct none_of
+			: public sprout::types::detail::none_of<Tuple, Predicate>
+		{};
+
+#if SPROUT_USE_TEMPLATE_ALIASES
+		template<typename Tuple, typename Predicate>
+		using none_of_t = typename sprout::types::none_of<Tuple, Predicate>::type;
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
+
+#if SPROUT_USE_VARIABLE_TEMPLATES
+		template<typename Tuple, typename Predicate>
+		SPROUT_STATIC_CONSTEXPR bool none_of_v = sprout::types::none_of<Tuple, Predicate>::value;
+#endif	// #if SPROUT_USE_VARIABLE_TEMPLATES
+	}	// namespace types
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_ALGORITHM_NONE_OF_HPP
diff --git a/sprout/type/algorithm/none_of_same.hpp b/sprout/type/algorithm/none_of_same.hpp
new file mode 100644
index 00000000..f6f3373d
--- /dev/null
+++ b/sprout/type/algorithm/none_of_same.hpp
@@ -0,0 +1,79 @@
+/*=============================================================================
+  Copyright (c) 2011-2017 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_ALGORITHM_NONE_OF_SAME_HPP
+#define SPROUT_TYPE_ALGORITHM_NONE_OF_SAME_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/workaround/std/cstddef.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type/tuple.hpp>
+
+namespace sprout {
+	namespace types {
+		namespace detail {
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot,
+				bool C1 = (Pivot == 0)
+			>
+			struct none_of_same_impl;
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct none_of_same_impl<Tuple, T, First, Last, Pivot, true>
+				: public sprout::bool_constant<
+					!std::is_same<typename sprout::types::tuple_element<First, Tuple>::type, T>::value
+				>
+			{};
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct none_of_same_impl<Tuple, T, First, Last, Pivot, false>
+				: public sprout::bool_constant<
+					sprout::types::detail::none_of_same_impl<
+						Tuple, T, First, First + Pivot,
+						Pivot / 2
+					>::value
+					&& sprout::types::detail::none_of_same_impl<
+						Tuple, T, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+				>
+			{};
+			template<typename Tuple, typename T, std::size_t Size = sprout::types::tuple_size<Tuple>::value>
+			struct none_of_same
+				: public sprout::types::detail::none_of_same_impl<Tuple, T, 0, Size, Size / 2>
+			{};
+			template<typename Tuple, typename T>
+			struct none_of_same<Tuple, T, 0>
+				: public sprout::true_type
+			{};
+		}	// namespace detail
+		//
+		// none_of_same
+		//
+		template<typename Tuple, typename T>
+		struct none_of_same
+			: public sprout::types::detail::none_of_same<Tuple, T>
+		{};
+
+#if SPROUT_USE_TEMPLATE_ALIASES
+		template<typename Tuple, typename T>
+		using none_of_same_t = typename sprout::types::none_of_same<Tuple, T>::type;
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
+
+#if SPROUT_USE_VARIABLE_TEMPLATES
+		template<typename Tuple, typename T>
+		SPROUT_STATIC_CONSTEXPR bool none_of_same_v = sprout::types::none_of_same<Tuple, T>::value;
+#endif	// #if SPROUT_USE_VARIABLE_TEMPLATES
+	}	// namespace types
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_ALGORITHM_NONE_OF_SAME_HPP
diff --git a/sprout/type/algorithm/one_of.hpp b/sprout/type/algorithm/one_of.hpp
new file mode 100644
index 00000000..1d482bad
--- /dev/null
+++ b/sprout/type/algorithm/one_of.hpp
@@ -0,0 +1,115 @@
+/*=============================================================================
+  Copyright (c) 2011-2017 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_ALGORITHM_ONE_OF_HPP
+#define SPROUT_TYPE_ALGORITHM_ONE_OF_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/workaround/std/cstddef.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type/apply.hpp>
+#include <sprout/type/tuple.hpp>
+
+namespace sprout {
+	namespace types {
+		namespace detail {
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot,
+				bool C1 = (Pivot == 0)
+			>
+			struct one_of_impl_1;
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct one_of_impl_1<Tuple, Predicate, First, Last, Pivot, true>
+				: public sprout::bool_constant<
+					!sprout::types::apply<Predicate, typename sprout::types::tuple_element<First, Tuple>::type>::type::value
+				>
+			{};
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct one_of_impl_1<Tuple, Predicate, First, Last, Pivot, false>
+				: public sprout::bool_constant<
+					sprout::types::detail::one_of_impl_1<
+						Tuple, Predicate, First, First + Pivot,
+						Pivot / 2
+					>::value
+					&& sprout::types::detail::one_of_impl_1<
+						Tuple, Predicate, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+				>
+			{};
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot,
+				bool C1 = (Pivot == 0)
+			>
+			struct one_of_impl;
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct one_of_impl<Tuple, Predicate, First, Last, Pivot, true>
+				: public sprout::bool_constant<
+					sprout::types::apply<Predicate, typename sprout::types::tuple_element<First, Tuple>::type>::type::value
+				>
+			{};
+			template<
+				typename Tuple, typename Predicate, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct one_of_impl<Tuple, Predicate, First, Last, Pivot, false>
+				: public sprout::bool_constant<
+					sprout::types::detail::one_of_impl<
+						Tuple, Predicate, First, First + Pivot,
+						Pivot / 2
+					>::value
+					? sprout::types::detail::one_of_impl_1<
+						Tuple, Predicate, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+					: sprout::types::detail::one_of_impl<
+						Tuple, Predicate, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+				>
+			{};
+			template<typename Tuple, typename Predicate, std::size_t Size = sprout::types::tuple_size<Tuple>::value>
+			struct one_of
+				: public sprout::types::detail::one_of_impl<Tuple, Predicate, 0, Size, Size / 2>
+			{};
+			template<typename Tuple, typename Predicate>
+			struct one_of<Tuple, Predicate, 0>
+				: public sprout::true_type
+			{};
+		}	// namespace detail
+		//
+		// one_of
+		//
+		template<typename Tuple, typename Predicate>
+		struct one_of
+			: public sprout::types::detail::one_of<Tuple, Predicate>
+		{};
+
+#if SPROUT_USE_TEMPLATE_ALIASES
+		template<typename Tuple, typename Predicate>
+		using one_of_t = typename sprout::types::one_of<Tuple, Predicate>::type;
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
+
+#if SPROUT_USE_VARIABLE_TEMPLATES
+		template<typename Tuple, typename Predicate>
+		SPROUT_STATIC_CONSTEXPR bool one_of_v = sprout::types::one_of<Tuple, Predicate>::value;
+#endif	// #if SPROUT_USE_VARIABLE_TEMPLATES
+	}	// namespace types
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_ALGORITHM_ONE_OF_HPP
diff --git a/sprout/type/algorithm/one_of_same.hpp b/sprout/type/algorithm/one_of_same.hpp
new file mode 100644
index 00000000..1bb86b6e
--- /dev/null
+++ b/sprout/type/algorithm/one_of_same.hpp
@@ -0,0 +1,114 @@
+/*=============================================================================
+  Copyright (c) 2011-2017 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_ALGORITHM_ONE_OF_SAME_HPP
+#define SPROUT_TYPE_ALGORITHM_ONE_OF_SAME_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/workaround/std/cstddef.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type/tuple.hpp>
+
+namespace sprout {
+	namespace types {
+		namespace detail {
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot,
+				bool C1 = (Pivot == 0)
+			>
+			struct one_of_same_impl_1;
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct one_of_same_impl_1<Tuple, T, First, Last, Pivot, true>
+				: public sprout::bool_constant<
+					!std::is_same<typename sprout::types::tuple_element<First, Tuple>::type, T>::value
+				>
+			{};
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct one_of_same_impl_1<Tuple, T, First, Last, Pivot, false>
+				: public sprout::bool_constant<
+					sprout::types::detail::one_of_same_impl_1<
+						Tuple, T, First, First + Pivot,
+						Pivot / 2
+					>::value
+					&& sprout::types::detail::one_of_same_impl_1<
+						Tuple, T, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+				>
+			{};
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot,
+				bool C1 = (Pivot == 0)
+			>
+			struct one_of_same_impl;
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct one_of_same_impl<Tuple, T, First, Last, Pivot, true>
+				: public sprout::bool_constant<
+					std::is_same<typename sprout::types::tuple_element<First, Tuple>::type, T>::value
+				>
+			{};
+			template<
+				typename Tuple, typename T, std::size_t First, std::size_t Last,
+				std::size_t Pivot
+			>
+			struct one_of_same_impl<Tuple, T, First, Last, Pivot, false>
+				: public sprout::bool_constant<
+					sprout::types::detail::one_of_same_impl<
+						Tuple, T, First, First + Pivot,
+						Pivot / 2
+					>::value
+					? sprout::types::detail::one_of_same_impl_1<
+						Tuple, T, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+					: sprout::types::detail::one_of_same_impl<
+						Tuple, T, First + Pivot, Last,
+						(Last - First - Pivot) / 2
+					>::value
+				>
+			{};
+			template<typename Tuple, typename T, std::size_t Size = sprout::types::tuple_size<Tuple>::value>
+			struct one_of_same
+				: public sprout::types::detail::one_of_same_impl<Tuple, T, 0, Size, Size / 2>
+			{};
+			template<typename Tuple, typename T>
+			struct one_of_same<Tuple, T, 0>
+				: public sprout::true_type
+			{};
+		}	// namespace detail
+		//
+		// one_of_same
+		//
+		template<typename Tuple, typename T>
+		struct one_of_same
+			: public sprout::types::detail::one_of_same<Tuple, T>
+		{};
+
+#if SPROUT_USE_TEMPLATE_ALIASES
+		template<typename Tuple, typename T>
+		using one_of_same_t = typename sprout::types::one_of_same<Tuple, T>::type;
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
+
+#if SPROUT_USE_VARIABLE_TEMPLATES
+		template<typename Tuple, typename T>
+		SPROUT_STATIC_CONSTEXPR bool one_of_same_v = sprout::types::one_of_same<Tuple, T>::value;
+#endif	// #if SPROUT_USE_VARIABLE_TEMPLATES
+	}	// namespace types
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_ALGORITHM_ONE_OF_SAME_HPP
diff --git a/sprout/type_traits/has_unique_object_representations.hpp b/sprout/type_traits/has_unique_object_representations.hpp
new file mode 100644
index 00000000..1f84e828
--- /dev/null
+++ b/sprout/type_traits/has_unique_object_representations.hpp
@@ -0,0 +1,41 @@
+/*=============================================================================
+  Copyright (c) 2011-2017 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATIONS_HPP
+#define SPROUT_TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATIONS_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/detail/predef.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type_traits/remove_cv.hpp>
+#include <sprout/type_traits/remove_all_extents.hpp>
+
+namespace sprout {
+	//
+	// has_unique_object_representations
+	//
+#if SPROUT_CLANG_HAS_FUTURE(has_unique_object_representations) || SPROUT_GCC_OR_LATER(7, 0, 0)
+	template<typename T>
+	struct has_unique_object_representations
+		: public sprout::bool_constant<
+			__has_unique_object_representations(typename sprout::remove_cv<typename sprout::remove_all_extents<T>::type>::type)
+		>
+	{};
+#else	// #if SPROUT_CLANG_HAS_FUTURE(has_unique_object_representations) || SPROUT_GCC_OR_LATER(7, 0, 0)
+	template<typename T>
+	struct has_unique_object_representations
+		: public sprout::false_type
+	{};
+#endif	// #if SPROUT_CLANG_HAS_FUTURE(has_unique_object_representations) || SPROUT_GCC_OR_LATER(7, 0, 0)
+
+#if SPROUT_USE_VARIABLE_TEMPLATES
+	template<typename T>
+	SPROUT_STATIC_CONSTEXPR bool has_unique_object_representations_v = sprout::has_unique_object_representations<T>::value;
+#endif	// #if SPROUT_USE_VARIABLE_TEMPLATES
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATIONS_HPP
diff --git a/sprout/type_traits/invoke_result.hpp b/sprout/type_traits/invoke_result.hpp
new file mode 100644
index 00000000..14310fcf
--- /dev/null
+++ b/sprout/type_traits/invoke_result.hpp
@@ -0,0 +1,29 @@
+/*=============================================================================
+  Copyright (c) 2011-2017 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_TRAITS_INVOKE_RESULT_HPP
+#define SPROUT_TYPE_TRAITS_INVOKE_RESULT_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/type_traits/result_of.hpp>
+
+namespace sprout {
+	//
+	// invoke_result
+	//
+	template<typename F, typename... Args>
+	struct invoke_result
+		: public sprout::detail::invoke_result<void, F, Args...>
+	{};
+
+#if SPROUT_USE_TEMPLATE_ALIASES
+	template<typename F, typename... Args>
+	using invoke_result_t = typename sprout::invoke_result<F, Args...>::type;
+#endif	// #if SPROUT_USE_TEMPLATE_ALIASES
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_TRAITS_INVOKE_RESULT_HPP
diff --git a/sprout/type_traits/is_aggregate.hpp b/sprout/type_traits/is_aggregate.hpp
new file mode 100644
index 00000000..0c85f6e6
--- /dev/null
+++ b/sprout/type_traits/is_aggregate.hpp
@@ -0,0 +1,41 @@
+/*=============================================================================
+  Copyright (c) 2011-2017 Bolero MURAKAMI
+  https://github.com/bolero-MURAKAMI/Sprout
+
+  Distributed under the Boost Software License, Version 1.0. (See accompanying
+  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+#ifndef SPROUT_TYPE_TRAITS_IS_AGGREGATE_HPP
+#define SPROUT_TYPE_TRAITS_IS_AGGREGATE_HPP
+
+#include <sprout/config.hpp>
+#include <sprout/detail/predef.hpp>
+#include <sprout/type_traits/integral_constant.hpp>
+#include <sprout/type_traits/remove_cv.hpp>
+#include <sprout/type_traits/remove_all_extents.hpp>
+
+namespace sprout {
+	//
+	// is_aggregate
+	//
+#if SPROUT_CLANG_HAS_FUTURE(is_aggregate) || SPROUT_GCC_OR_LATER(7, 0, 0)
+	template<typename T>
+	struct is_aggregate
+		: public sprout::bool_constant<
+			__is_aggregate(typename sprout::remove_cv<typename sprout::remove_all_extents<T>::type>::type)
+		>
+	{};
+#else	// #if SPROUT_CLANG_HAS_FUTURE(is_aggregate) || SPROUT_GCC_OR_LATER(7, 0, 0)
+	template<typename T>
+	struct is_aggregate
+		: public sprout::false_type
+	{};
+#endif	// #if SPROUT_CLANG_HAS_FUTURE(is_aggregate) || SPROUT_GCC_OR_LATER(7, 0, 0)
+
+#if SPROUT_USE_VARIABLE_TEMPLATES
+	template<typename T>
+	SPROUT_STATIC_CONSTEXPR bool is_aggregate_v = sprout::is_aggregate<T>::value;
+#endif	// #if SPROUT_USE_VARIABLE_TEMPLATES
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_TYPE_TRAITS_IS_AGGREGATE_HPP
diff --git a/sprout/type_traits/property.hpp b/sprout/type_traits/property.hpp
index fd0d0f5a..cccd2f8f 100644
--- a/sprout/type_traits/property.hpp
+++ b/sprout/type_traits/property.hpp
@@ -17,10 +17,12 @@
 #include <sprout/type_traits/is_standard_layout.hpp>
 #include <sprout/type_traits/is_pod.hpp>
 #include <sprout/type_traits/is_literal_type.hpp>
+#include <sprout/type_traits/has_unique_object_representations.hpp>
 #include <sprout/type_traits/is_empty.hpp>
 #include <sprout/type_traits/is_polymorphic.hpp>
 #include <sprout/type_traits/is_abstract.hpp>
 #include <sprout/type_traits/is_final.hpp>
+#include <sprout/type_traits/is_aggregate.hpp>
 #include <sprout/type_traits/is_signed.hpp>
 #include <sprout/type_traits/is_unsigned.hpp>
 #include <sprout/type_traits/is_constructible.hpp>
diff --git a/sprout/type_traits/result_of.hpp b/sprout/type_traits/result_of.hpp
index 42adab6c..41bf7ab4 100644
--- a/sprout/type_traits/result_of.hpp
+++ b/sprout/type_traits/result_of.hpp
@@ -8,215 +8,55 @@
 #ifndef SPROUT_TYPE_TRAITS_RESULT_OF_HPP
 #define SPROUT_TYPE_TRAITS_RESULT_OF_HPP
 
-#if defined(_MSC_VER) && (_MSC_VER <= 1900)
-#	include <functional>
-#endif
 #include <utility>
-#include <type_traits>
 #include <sprout/config.hpp>
 #include <sprout/type_traits/identity.hpp>
-#include <sprout/detail/nil_base.hpp>
-#include <sprout/type/type_tuple.hpp>
 
 namespace sprout {
-#if defined(_MSC_VER) && (_MSC_VER <= 1900)
-	//
-	// result_of
-	//
-	using std::result_of;
-#else
-	//
-	// result_of
-	//
 	namespace detail {
-		struct result_of_memfun_ref_helper {
-		public:
-			template<typename F, typename T, typename... Args>
-			static sprout::identity<decltype((std::declval<T>().*std::declval<F>())(std::declval<Args>()...))> test(sprout::types::type_tuple<Args...>);
-			template<typename...>
-			static sprout::detail::nil_base test(...);
-		};
-#if defined(_MSC_VER) && (_MSC_VER > 1900)
-		template<
-			typename MemPtr, typename Arg, typename Args,
-			typename Base_ = typename sprout::identity<decltype(sprout::detail::result_of_memfun_ref_helper::test<MemPtr, Arg>(Args()))>::type
-		>
-		struct result_of_memfun_ref_impl
-			: public Base_
-		{};
-		template<typename MemPtr, typename Arg, typename... Args>
-		struct result_of_memfun_ref
-			: public sprout::detail::result_of_memfun_ref_impl<MemPtr, Arg, sprout::types::type_tuple<Args...> >
-		{};
-#else
-		template<typename MemPtr, typename Arg, typename... Args>
-		struct result_of_memfun_ref
-			: public sprout::identity<decltype(sprout::detail::result_of_memfun_ref_helper::test<MemPtr, Arg, Args...>(sprout::types::type_tuple<Args...>()))>::type
-		{};
-#endif
+		template<typename F, typename... Args>
+		inline SPROUT_CONSTEXPR decltype(std::declval<F>()(std::declval<Args>()...))
+		invoke(F&&, Args&&...);
 
-		struct result_of_memfun_deref_helper {
-		public:
-			template<typename F, typename T, typename... Args>
-			static sprout::identity<decltype(((*std::declval<T>()).*std::declval<F>())(std::declval<Args>()...))> test(sprout::types::type_tuple<Args...>);
-			template<typename...>
-			static sprout::detail::nil_base test(...);
-		};
-#if defined(_MSC_VER) && (_MSC_VER > 1900)
-		template<
-			typename MemPtr, typename Arg, typename Args,
-			typename Base_ = typename sprout::identity<decltype(sprout::detail::result_of_memfun_deref_helper::test<MemPtr, Arg>(Args()))>::type
-		>
-		struct result_of_memfun_deref_impl
-			: public Base_
-		{};
-		template<typename MemPtr, typename Arg, typename... Args>
-		struct result_of_memfun_deref
-			: public sprout::detail::result_of_memfun_deref_impl<MemPtr, Arg, sprout::types::type_tuple<Args...> >
-		{};
-#else
-		template<typename MemPtr, typename Arg, typename... Args>
-		struct result_of_memfun_deref
-			: public sprout::identity<decltype(sprout::detail::result_of_memfun_deref_helper::test<MemPtr, Arg, Args...>(sprout::types::type_tuple<Args...>()))>::type
-		{};
-#endif
+		template<typename Base, typename T, typename Derived>
+		inline SPROUT_CONSTEXPR decltype(std::declval<Derived>().*(std::declval<T Base::*>()))
+		invoke(T Base::*, Derived&&);
 
-		struct result_of_memobj_ref_helper {
-		public:
-			template<typename F, typename T>
-			static sprout::identity<decltype(std::declval<T>().*std::declval<F>())> test(int);
-			template<typename, typename>
-			static sprout::detail::nil_base test(...);
-		};
-#if defined(_MSC_VER) && (_MSC_VER > 1900)
-		template<
-			typename MemPtr, typename Arg,
-			typename Base_ = typename sprout::identity<decltype(sprout::detail::result_of_memobj_ref_helper::test<MemPtr, Arg>(0))>::type
-		>
-		struct result_of_memobj_ref
-			: public Base_
-		{};
-#else
-		template<typename MemPtr, typename Arg>
-		struct result_of_memobj_ref
-			: public sprout::identity<decltype(sprout::detail::result_of_memobj_ref_helper::test<MemPtr, Arg>(0))>::type
-		{};
-#endif
+		template<typename PMD, typename Pointer>
+		inline SPROUT_CONSTEXPR decltype((*std::declval<Pointer>()).*(std::declval<PMD>()))
+		invoke(PMD&&, Pointer&&);
 
-		struct result_of_memobj_deref_helper {
-		public:
-			template<typename F, typename T>
-			static sprout::identity<decltype((*std::declval<T>()).*std::declval<F>())> test(int);
-			template<typename, typename>
-			static sprout::detail::nil_base test(...);
-		};
-#if defined(_MSC_VER) && (_MSC_VER > 1900)
-		template<
-			typename MemPtr, typename Arg,
-			typename Base_ = typename sprout::identity<decltype(sprout::detail::result_of_memobj_deref_helper::test<MemPtr, Arg>(0))>::type
-		>
-		struct result_of_memobj_deref
-			: public Base_
-		{};
-#else
-		template<typename MemPtr, typename Arg>
-		struct result_of_memobj_deref
-			: public sprout::identity<decltype(sprout::detail::result_of_memobj_deref_helper::test<MemPtr, Arg>(0))>::type
-		{};
-#endif
+		template<typename Base, typename T, typename Derived, typename... Args>
+		inline SPROUT_CONSTEXPR decltype((std::declval<Derived>().*(std::declval<T Base::*>()))(std::declval<Args>()...))
+		invoke(T Base::*, Derived&&, Args&&...);
 
-		template<typename MemPtr, typename Arg>
-		struct result_of_memobj_impl;
-		template<typename R, typename Class, typename Arg>
-		struct result_of_memobj_impl<R Class::*, Arg> {
-		public:
-			typedef typename std::remove_cv<typename std::remove_reference<Arg>::type>::type argval_type;
-			typedef R Class::* mem_ptr_type;
-			typedef typename std::conditional<
-				std::is_same<argval_type, Class>::value || std::is_base_of<Class, argval_type>::value,
-				sprout::detail::result_of_memobj_ref<mem_ptr_type, Arg>,
-				sprout::detail::result_of_memobj_deref<mem_ptr_type, Arg>
-			>::type type;
-		};
-		template<typename MemPtr, typename Arg>
-		struct result_of_memobj
-			: public sprout::detail::result_of_memobj_impl<MemPtr, Arg>::type
-		{};
+		template<typename PMF, typename Pointer, typename... Args>
+		inline SPROUT_CONSTEXPR decltype(((*std::declval<Pointer>()).*(std::declval<PMF>()))(std::declval<Args>()...))
+		invoke(PMF&& pmf, Pointer&& ptr, Args&&... args);
+	}	// namespace detail
 
-		template<typename MemPtr, typename Arg, typename... Args>
-		struct result_of_memfun_impl;
-		template<typename R, typename Class, typename Arg, typename... Args>
-		struct result_of_memfun_impl<R Class::*, Arg, Args...> {
-		public:
-			typedef typename std::remove_cv<typename std::remove_reference<Arg>::type>::type argval_type;
-			typedef R Class::* mem_ptr_type;
-			typedef typename std::conditional<
-				std::is_same<argval_type, Class>::value || std::is_base_of<Class, argval_type>::value,
-				result_of_memfun_ref<mem_ptr_type, Arg, Args...>,
-				result_of_memfun_deref<mem_ptr_type, Arg, Args...>
-			>::type type;
-		};
-		template<typename MemPtr, typename Arg, typename... Args>
-		struct result_of_memfun
-			: public sprout::detail::result_of_memfun_impl<MemPtr, Arg, Args...>::type
+	namespace detail {
+		template<typename Void, typename, typename...>
+		struct invoke_result {};
+		template<typename F, typename...Args>
+		struct invoke_result<decltype(void(sprout::detail::invoke(std::declval<F>(), std::declval<Args>()...))), F, Args...>
+			: public sprout::identity<decltype(sprout::detail::invoke(std::declval<F>(), std::declval<Args>()...))>
 		{};
+	}	// namespace detail
 
-		struct result_of_other_impl {
-		public:
-			template<typename F, typename... Args>
-			static sprout::identity<decltype(std::declval<F>()(std::declval<Args>()...))> test(int);
-			template<typename, typename...>
-			static sprout::detail::nil_base test(...);
-		};
-#if defined(_MSC_VER)
-		template<typename Functor, typename... Args>
-		struct result_of_other_base {
-		public:
-			typedef typename sprout::identity<decltype(sprout::detail::result_of_other_impl::test<Functor, Args...>(0))>::type type;
-		};
-		template<typename Functor, typename... Args>
-		struct result_of_other
-			: public sprout::detail::result_of_other_base<Functor, Args...>::type
-		{};
-#else
-		template<typename Functor, typename... Args>
-		struct result_of_other
-			: public sprout::identity<decltype(sprout::detail::result_of_other_impl::test<Functor, Args...>(0))>::type
-		{};
-#endif
-
-		template<bool, bool, typename Functor, typename... Args>
-		struct result_of_impl
-			: public sprout::identity<sprout::detail::nil_base>::type
-		{};
-		template<typename MemPtr, typename Arg>
-		struct result_of_impl<true, false, MemPtr, Arg>
-			: public sprout::detail::result_of_memobj<typename std::decay<MemPtr>::type, Arg>
-		{};
-		template<typename MemPtr, typename Arg, typename... Args>
-		struct result_of_impl<false, true, MemPtr, Arg, Args...>
-			: public sprout::detail::result_of_memfun<typename std::decay<MemPtr>::type, Arg, Args...>
-		{};
-		template<typename Functor, typename... Args>
-		struct result_of_impl<false, false, Functor, Args...>
-			: public sprout::detail::result_of_other<Functor, Args...>
-		{};
-	}	//namespace detail
-	template<typename Signature>
+	//
+	// result_of
+	//
+	template<typename>
 	struct result_of;
-	template<typename Functor, typename... Args>
-	struct result_of<Functor(Args...)>
-		: public sprout::detail::result_of_impl<
-			std::is_member_object_pointer<typename std::remove_reference<Functor>::type>::value,
-			std::is_member_function_pointer<typename std::remove_reference<Functor>::type>::value,
-			Functor, Args...
-		>
+	template<typename F, typename... Args>
+	struct result_of<F(Args...)>
+		: public sprout::detail::invoke_result<void, F, Args...>
 	{};
-#endif
 
 #if SPROUT_USE_TEMPLATE_ALIASES
-	template<typename F, typename... ArgTypes>
-	using result_of_t = typename sprout::result_of<F(ArgTypes...)>::type;
+	template<typename T>
+	using result_of_t = typename sprout::result_of<T>::type;
 #endif	// #if SPROUT_USE_TEMPLATE_ALIASES
 }	// namespace sprout
 
diff --git a/sprout/type_traits/transformation.hpp b/sprout/type_traits/transformation.hpp
index 96248dec..258d39f9 100644
--- a/sprout/type_traits/transformation.hpp
+++ b/sprout/type_traits/transformation.hpp
@@ -18,6 +18,7 @@
 #include <sprout/type_traits/common_type.hpp>
 #include <sprout/type_traits/underlying_type.hpp>
 #include <sprout/type_traits/result_of.hpp>
+#include <sprout/type_traits/invoke_result.hpp>
 
 #include <sprout/type_traits/identity.hpp>
 #include <sprout/type_traits/common_decay.hpp>
diff --git a/tools/darkroom/darkcult.sh b/tools/darkroom/darkcult.sh
index 1511963a..d6dd6796 100755
--- a/tools/darkroom/darkcult.sh
+++ b/tools/darkroom/darkcult.sh
@@ -34,6 +34,11 @@ use_help=0
 darkcult_cpp=$(cd $(dirname $0); pwd)/darkcult.cpp
 darkcult_py=$(cd $(dirname $0); pwd)/darkcult.py
 
+get_used_mem() {
+	local mem_info=(`free -m | sed -n "/^Mem:/s/^Mem:[ \t]*//p"`)
+	echo -n "${mem_info[1]}"
+}
+
 args=`getopt -o s:S:o:C:w:h:W:H:l:t:r:b:O:D:I:P:fc -l source:,stagedir:,output:,compiler:,width:,height:,tile-width:,tile-height:,left:,top:,right:,bottom:,option:,define:,include:,max-procs:,force,continuable,runtime,version,help -- "$@"`
 if [ "$?" -ne 0 ]; then
 	echo >&2 "error: options parse error. See 'darkcult.sh --help'"
@@ -142,7 +147,7 @@ if [ ${use_version} -ne 0 ]; then
 	sprout_version_yyyymmdd=`sed -n "s/[ \t]*#[ \t]*define[ \t]\+SPROUT_VERSION_YYYYMMDD[ \t]\+//p" ${version_hpp_path}`
 	sprout_copyright=`sed -n "/\/\*=/,/=\*\//s/^[ \t]\+/  /p" ${version_hpp_path}`
 	echo "version:"
-	echo "  Sprout version (YYYYMMDD) = ${sprout_version_yyyymmdd}"
+	echo "  Sprout version(YYYYMMDD) = ${sprout_version_yyyymmdd}"
 	echo "copyright:"
 	echo "${sprout_copyright}"
 	exit 0
@@ -202,6 +207,7 @@ for ((y=0; y<height; y+=tile_height)); do
 done
 
 echo "rendering:"
+is_uncompleted=0
 start=${SECONDS}
 
 if [ -z "${max_procs}" ]; then
@@ -227,6 +233,7 @@ if [ -z "${max_procs}" ]; then
 				echo >&2 "  error: compile(${y}/${x}) failed."
 				exit 1
 			fi
+
 		done
 		echo ""
 
@@ -252,6 +259,7 @@ else
 	echo ""
 	if [ ${result} -eq 2 ]; then
 		echo "  compile terminated."
+		is_terminated=1
 		exit 0
 	elif [ ${result} -ne 0 ]; then
 		echo >&2 "  error: compile failed."
@@ -262,13 +270,15 @@ fi
 let elapsed=${SECONDS}-${start}
 echo "  elapsed(total) = ${elapsed}s"
 
-for ((y=0; y<height; y+=tile_height)); do
-	pushd ${stagedir}/${y}/ > /dev/null
-	pnmcat -lr $(ls *.ppm | sort -n) > ../${y}.ppm
+if [ ${is_uncompleted} -eq 0 ]; then
+	for ((y=0; y<height; y+=tile_height)); do
+		pushd ${stagedir}/${y}/ > /dev/null
+		pnmcat -lr $(ls *.ppm | sort -n) > ../${y}.ppm
+		popd > /dev/null
+	done
+	pushd ${stagedir} > /dev/null
+	pnmcat -tb $(ls *.ppm | sort -n) > ${output}
 	popd > /dev/null
-done
-pushd ${stagedir} > /dev/null
-pnmcat -tb $(ls *.ppm | sort -n) > ${output}
-popd > /dev/null
+fi
 
 echo "finished."
diff --git a/tools/testspr/test.sh b/tools/testspr/test.sh
index c3da0261..6693cdd0 100755
--- a/tools/testspr/test.sh
+++ b/tools/testspr/test.sh
@@ -177,7 +177,7 @@ if [ ${use_version} -ne 0 ]; then
 	sprout_version_yyyymmdd=`sed -n "s/[ \t]*#[ \t]*define[ \t]\+SPROUT_VERSION_YYYYMMDD[ \t]\+//p" ${version_hpp_path}`
 	sprout_copyright=`sed -n "/\/\*=/,/=\*\//s/^[ \t]\+/  /p" ${version_hpp_path}`
 	echo "version:"
-	echo "  Sprout version (YYYYMMDD) = ${sprout_version_yyyymmdd}"
+	echo "  Sprout version(YYYYMMDD) = ${sprout_version_yyyymmdd}"
 	echo "copyright:"
 	echo "${sprout_copyright}"
 	exit 0