diff --git a/sprout/algorithm/fixed/bogo_sort.hpp b/sprout/algorithm/fixed/bogo_sort.hpp
index a2e25080..3513dfc7 100644
--- a/sprout/algorithm/fixed/bogo_sort.hpp
+++ b/sprout/algorithm/fixed/bogo_sort.hpp
@@ -2,75 +2,28 @@
 #define SPROUT_ALGORITHM_FIXED_BOGO_SORT_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/tuple/tuple.hpp>
-#include <sprout/container/traits.hpp>
-#include <sprout/container/functions.hpp>
-#include <sprout/iterator/operation.hpp>
 #include <sprout/utility/forward.hpp>
-#include <sprout/algorithm/is_sorted.hpp>
+#include <sprout/utility/pair.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
-#include <sprout/algorithm/fixed/shuffle_result.hpp>
-#include HDR_FUNCTIONAL_SSCRISK_CEL_OR_SPROUT
+#include <sprout/algorithm/fixed/bogo_sort_result.hpp>
 
 namespace sprout {
 	namespace fixed {
-		namespace detail {
-			template<typename Container, typename Shuffled, typename Compare>
-			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
-			bogo_sort_impl_1(Shuffled const& shuffled, Compare comp) {
-				return sprout::is_sorted(
-					sprout::begin(sprout::tuples::get<0>(shuffled)),
-					sprout::end(sprout::tuples::get<0>(shuffled)),
-					comp
-					)
-					? sprout::tuples::get<0>(shuffled)
-					: sprout::fixed::detail::bogo_sort_impl_1<Container>(
-						sprout::fixed::shuffle_result(
-							sprout::tuples::get<0>(shuffled),
-							sprout::tuples::get<1>(shuffled)
-							),
-						comp
-						)
-					;
-			}
-			template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
-			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
-			bogo_sort_impl(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
-				return sprout::is_sorted(
-					sprout::begin(cont),
-					sprout::end(cont),
-					comp
-					)
-					? sprout::deep_copy(cont)
-					: sprout::fixed::detail::bogo_sort_impl_1<Container>(
-						sprout::fixed::shuffle_result(
-							cont,
-							sprout::forward<UniformRandomNumberGenerator>(g)
-							),
-						comp
-						)
-					;
-			}
-		}	// namespace detail
 		//
 		// bogo_sort
 		//
 		template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
 		bogo_sort(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
-			return sprout::fixed::detail::bogo_sort_impl(
-				cont,
-				sprout::forward<UniformRandomNumberGenerator>(g),
-				comp
+			return sprout::first(
+				sprout::fixed::bogo_sort_result(cont, sprout::forward<UniformRandomNumberGenerator>(g), comp)
 				);
 		}
 		template<typename Container, typename UniformRandomNumberGenerator>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
 		bogo_sort(Container const& cont, UniformRandomNumberGenerator&& g) {
-			return sprout::fixed::detail::bogo_sort_impl(
-				cont,
-				sprout::forward<UniformRandomNumberGenerator>(g),
-				NS_SSCRISK_CEL_OR_SPROUT::less<typename sprout::container_traits<Container>::value_type>()
+			return sprout::first(
+				sprout::fixed::bogo_sort_result(cont, sprout::forward<UniformRandomNumberGenerator>(g))
 				);
 		}
 	}	// namespace fixed
diff --git a/sprout/algorithm/fixed/bogo_sort_result.hpp b/sprout/algorithm/fixed/bogo_sort_result.hpp
index 96728ecc..86371a74 100644
--- a/sprout/algorithm/fixed/bogo_sort_result.hpp
+++ b/sprout/algorithm/fixed/bogo_sort_result.hpp
@@ -3,11 +3,11 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
-#include <sprout/tuple/tuple.hpp>
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
 #include <sprout/utility/forward.hpp>
+#include <sprout/utility/pair.hpp>
 #include <sprout/algorithm/is_sorted.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/shuffle_result.hpp>
@@ -16,53 +16,56 @@
 namespace sprout {
 	namespace fixed {
 		namespace detail {
-			template<typename Container, typename UniformRandomNumberGenerator, typename Shuffled, typename Compare>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				typename sprout::fixed::result_of::algorithm<Container>::type,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
-			bogo_sort_result_impl_1(Shuffled const& shuffled, Compare comp) {
-				return sprout::is_sorted(
-					sprout::begin(sprout::tuples::get<0>(shuffled)),
-					sprout::end(sprout::tuples::get<0>(shuffled)),
-					comp
+			template<typename ResultType, typename Compare, typename Difference>
+			inline SPROUT_CONSTEXPR sprout::pair<ResultType, bool>
+			bogo_sort_result_impl_1(
+				sprout::pair<ResultType, bool> const& current,
+				Compare comp, Difference n
+				)
+			{
+				typedef sprout::pair<ResultType, bool> type;
+			return current.second ? current
+				: n == 1 ? sprout::is_sorted(sprout::begin(sprout::first(current.first)), sprout::end(sprout::first(current.first)), comp)
+					? type(current.first, true)
+					: type(sprout::fixed::shuffle_result(sprout::first(current.first), sprout::second(current.first)), false)
+				: sprout::fixed::detail::bogo_sort_result_impl_1<ResultType>(
+					sprout::fixed::detail::bogo_sort_result_impl_1<ResultType>(
+						current,
+						comp, n / 2
+						),
+					comp, n - n / 2
 					)
-					? shuffled
-					: sprout::fixed::detail::bogo_sort_result_impl_1<Container, UniformRandomNumberGenerator>(
-						sprout::fixed::shuffle_result(
-							sprout::tuples::get<0>(shuffled),
-							sprout::tuples::get<1>(shuffled)
+				;
+			}
+			template<typename ResultType, typename Compare, typename Difference>
+			inline SPROUT_CONSTEXPR sprout::pair<ResultType, bool>
+			bogo_sort_result_impl(
+				sprout::pair<ResultType, bool> const& current,
+				Compare comp, Difference n
+				)
+			{
+				typedef sprout::pair<ResultType, bool> type;
+				return current.second ? current
+					: sprout::fixed::detail::bogo_sort_result_impl<ResultType>(
+						sprout::fixed::detail::bogo_sort_result_impl_1<ResultType>(
+							current,
+							comp, n
 							),
-						comp
+						comp, n * 2
 						)
 					;
 			}
 			template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				typename sprout::fixed::result_of::algorithm<Container>::type,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
-			bogo_sort_result_impl(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
-				typedef sprout::tuples::tuple<
-					typename sprout::fixed::result_of::algorithm<Container>::type,
-					typename std::decay<UniformRandomNumberGenerator>::type
-				> result_type;
-				return sprout::is_sorted(
-					sprout::begin(cont),
-					sprout::end(cont),
-					comp
-					)
-					? result_type(
-						sprout::deep_copy(cont),
-						sprout::forward<UniformRandomNumberGenerator>(g)
-						)
-					: sprout::fixed::detail::bogo_sort_result_impl_1<Container, UniformRandomNumberGenerator>(
-						sprout::fixed::shuffle_result(
-							cont,
-							sprout::forward<UniformRandomNumberGenerator>(g)
-							),
-						comp
-						)
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
+			bogo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
+				typedef typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type result_type;
+				typedef sprout::pair<result_type, bool> type;
+				return sprout::is_sorted(sprout::begin(cont), sprout::end(cont), comp)
+					? result_type(sprout::deep_copy(cont), sprout::forward<UniformRandomNumberGenerator>(g))
+					: sprout::fixed::detail::bogo_sort_result_impl<result_type>(
+						type(sprout::fixed::shuffle_result(cont, sprout::forward<UniformRandomNumberGenerator>(g)), false),
+						comp, static_cast<typename sprout::container_traits<Container>::difference_type>(1)
+						).first
 					;
 			}
 		}	// namespace detail
@@ -70,24 +73,18 @@ namespace sprout {
 		// bogo_sort_result
 		//
 		template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
-		inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-			typename sprout::fixed::result_of::algorithm<Container>::type,
-			typename std::decay<UniformRandomNumberGenerator>::type
-		>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
 		bogo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
-			return sprout::fixed::detail::bogo_sort_result_impl(
+			return sprout::fixed::detail::bogo_sort_result(
 				cont,
 				sprout::forward<UniformRandomNumberGenerator>(g),
 				comp
 				);
 		}
 		template<typename Container, typename UniformRandomNumberGenerator>
-		inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-			typename sprout::fixed::result_of::algorithm<Container>::type,
-			typename std::decay<UniformRandomNumberGenerator>::type
-		>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
 		bogo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g) {
-			return sprout::fixed::detail::bogo_sort_result_impl(
+			return sprout::fixed::detail::bogo_sort_result(
 				cont,
 				sprout::forward<UniformRandomNumberGenerator>(g),
 				NS_SSCRISK_CEL_OR_SPROUT::less<typename sprout::container_traits<Container>::value_type>()
diff --git a/sprout/algorithm/fixed/bozo_sort.hpp b/sprout/algorithm/fixed/bozo_sort.hpp
index 84132ca0..5b4db6f7 100644
--- a/sprout/algorithm/fixed/bozo_sort.hpp
+++ b/sprout/algorithm/fixed/bozo_sort.hpp
@@ -2,75 +2,28 @@
 #define SPROUT_ALGORITHM_FIXED_BOZO_SORT_HPP
 
 #include <sprout/config.hpp>
-#include <sprout/tuple/tuple.hpp>
-#include <sprout/container/traits.hpp>
-#include <sprout/container/functions.hpp>
-#include <sprout/iterator/operation.hpp>
 #include <sprout/utility/forward.hpp>
-#include <sprout/algorithm/is_sorted.hpp>
+#include <sprout/utility/pair.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
-#include <sprout/algorithm/fixed/random_swap_result.hpp>
-#include HDR_FUNCTIONAL_SSCRISK_CEL_OR_SPROUT
+#include <sprout/algorithm/fixed/bozo_sort_result.hpp>
 
 namespace sprout {
 	namespace fixed {
-		namespace detail {
-			template<typename Container, typename Shuffled, typename Compare>
-			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
-			bozo_sort_impl_1(Shuffled const& shuffled, Compare comp) {
-				return sprout::is_sorted(
-					sprout::begin(sprout::tuples::get<0>(shuffled)),
-					sprout::end(sprout::tuples::get<0>(shuffled)),
-					comp
-					)
-					? sprout::tuples::get<0>(shuffled)
-					: sprout::fixed::detail::bozo_sort_impl_1<Container>(
-						sprout::fixed::random_swap_result(
-							sprout::tuples::get<0>(shuffled),
-							sprout::tuples::get<1>(shuffled)
-							),
-						comp
-						)
-					;
-			}
-			template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
-			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
-			bozo_sort_impl(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
-				return sprout::is_sorted(
-					sprout::begin(cont),
-					sprout::end(cont),
-					comp
-					)
-					? sprout::deep_copy(cont)
-					: sprout::fixed::detail::bozo_sort_impl_1<Container>(
-						sprout::fixed::random_swap_result(
-							cont,
-							sprout::forward<UniformRandomNumberGenerator>(g)
-							),
-						comp
-						)
-					;
-			}
-		}	// namespace detail
 		//
 		// bozo_sort
 		//
 		template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
 		bozo_sort(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
-			return sprout::fixed::detail::bozo_sort_impl(
-				cont,
-				sprout::forward<UniformRandomNumberGenerator>(g),
-				comp
+			return sprout::first(
+				sprout::fixed::bozo_sort_result(cont, sprout::forward<UniformRandomNumberGenerator>(g), comp)
 				);
 		}
 		template<typename Container, typename UniformRandomNumberGenerator>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
 		bozo_sort(Container const& cont, UniformRandomNumberGenerator&& g) {
-			return sprout::fixed::detail::bozo_sort_impl(
-				cont,
-				sprout::forward<UniformRandomNumberGenerator>(g),
-				NS_SSCRISK_CEL_OR_SPROUT::less<typename sprout::container_traits<Container>::value_type>()
+			return sprout::first(
+				sprout::fixed::bozo_sort_result(cont, sprout::forward<UniformRandomNumberGenerator>(g))
 				);
 		}
 	}	// namespace fixed
diff --git a/sprout/algorithm/fixed/bozo_sort_result.hpp b/sprout/algorithm/fixed/bozo_sort_result.hpp
index a63987e9..e5bfffd5 100644
--- a/sprout/algorithm/fixed/bozo_sort_result.hpp
+++ b/sprout/algorithm/fixed/bozo_sort_result.hpp
@@ -3,11 +3,11 @@
 
 #include <type_traits>
 #include <sprout/config.hpp>
-#include <sprout/tuple/tuple.hpp>
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
 #include <sprout/utility/forward.hpp>
+#include <sprout/utility/pair.hpp>
 #include <sprout/algorithm/is_sorted.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/random_swap_result.hpp>
@@ -16,53 +16,56 @@
 namespace sprout {
 	namespace fixed {
 		namespace detail {
-			template<typename Container, typename UniformRandomNumberGenerator, typename Shuffled, typename Compare>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				typename sprout::fixed::result_of::algorithm<Container>::type,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
-			bozo_sort_result_impl_1(Shuffled const& shuffled, Compare comp) {
-				return sprout::is_sorted(
-					sprout::begin(sprout::tuples::get<0>(shuffled)),
-					sprout::end(sprout::tuples::get<0>(shuffled)),
-					comp
+			template<typename ResultType, typename Compare, typename Difference>
+			inline SPROUT_CONSTEXPR sprout::pair<ResultType, bool>
+			bozo_sort_result_impl_1(
+				sprout::pair<ResultType, bool> const& current,
+				Compare comp, Difference n
+				)
+			{
+				typedef sprout::pair<ResultType, bool> type;
+			return current.second ? current
+				: n == 1 ? sprout::is_sorted(sprout::begin(sprout::first(current.first)), sprout::end(sprout::first(current.first)), comp)
+					? type(current.first, true)
+					: type(sprout::fixed::random_swap_result(sprout::first(current.first), sprout::second(current.first)), false)
+				: sprout::fixed::detail::bozo_sort_result_impl_1<ResultType>(
+					sprout::fixed::detail::bozo_sort_result_impl_1<ResultType>(
+						current,
+						comp, n / 2
+						),
+					comp, n - n / 2
 					)
-					? shuffled
-					: sprout::fixed::detail::bozo_sort_result_impl_1<Container, UniformRandomNumberGenerator>(
-						sprout::fixed::random_swap_result(
-							sprout::tuples::get<0>(shuffled),
-							sprout::tuples::get<1>(shuffled)
+				;
+			}
+			template<typename ResultType, typename Compare, typename Difference>
+			inline SPROUT_CONSTEXPR sprout::pair<ResultType, bool>
+			bozo_sort_result_impl(
+				sprout::pair<ResultType, bool> const& current,
+				Compare comp, Difference n
+				)
+			{
+				typedef sprout::pair<ResultType, bool> type;
+				return current.second ? current
+					: sprout::fixed::detail::bozo_sort_result_impl<ResultType>(
+						sprout::fixed::detail::bozo_sort_result_impl_1<ResultType>(
+							current,
+							comp, n
 							),
-						comp
+						comp, n * 2
 						)
 					;
 			}
 			template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				typename sprout::fixed::result_of::algorithm<Container>::type,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
-			bozo_sort_result_impl(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
-				typedef sprout::tuples::tuple<
-					typename sprout::fixed::result_of::algorithm<Container>::type,
-					typename std::decay<UniformRandomNumberGenerator>::type
-				> result_type;
-				return sprout::is_sorted(
-					sprout::begin(cont),
-					sprout::end(cont),
-					comp
-					)
-					? result_type(
-						sprout::deep_copy(cont),
-						sprout::forward<UniformRandomNumberGenerator>(g)
-						)
-					: sprout::fixed::detail::bozo_sort_result_impl_1<Container, UniformRandomNumberGenerator>(
-						sprout::fixed::random_swap_result(
-							cont,
-							sprout::forward<UniformRandomNumberGenerator>(g)
-							),
-						comp
-						)
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
+			bozo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
+				typedef typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type result_type;
+				typedef sprout::pair<result_type, bool> type;
+				return sprout::is_sorted(sprout::begin(cont), sprout::end(cont), comp)
+					? result_type(sprout::deep_copy(cont), sprout::forward<UniformRandomNumberGenerator>(g))
+					: sprout::fixed::detail::bozo_sort_result_impl<result_type>(
+						type(sprout::fixed::random_swap_result(cont, sprout::forward<UniformRandomNumberGenerator>(g)), false),
+						comp, static_cast<typename sprout::container_traits<Container>::difference_type>(1)
+						).first
 					;
 			}
 		}	// namespace detail
@@ -70,24 +73,18 @@ namespace sprout {
 		// bozo_sort_result
 		//
 		template<typename Container, typename UniformRandomNumberGenerator, typename Compare>
-		inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-			typename sprout::fixed::result_of::algorithm<Container>::type,
-			typename std::decay<UniformRandomNumberGenerator>::type
-		>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
 		bozo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g, Compare comp) {
-			return sprout::fixed::detail::bozo_sort_result_impl(
+			return sprout::fixed::detail::bozo_sort_result(
 				cont,
 				sprout::forward<UniformRandomNumberGenerator>(g),
 				comp
 				);
 		}
 		template<typename Container, typename UniformRandomNumberGenerator>
-		inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-			typename sprout::fixed::result_of::algorithm<Container>::type,
-			typename std::decay<UniformRandomNumberGenerator>::type
-		>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
 		bozo_sort_result(Container const& cont, UniformRandomNumberGenerator&& g) {
-			return sprout::fixed::detail::bozo_sort_result_impl(
+			return sprout::fixed::detail::bozo_sort_result(
 				cont,
 				sprout::forward<UniformRandomNumberGenerator>(g),
 				NS_SSCRISK_CEL_OR_SPROUT::less<typename sprout::container_traits<Container>::value_type>()
diff --git a/sprout/algorithm/fixed/random_swap.hpp b/sprout/algorithm/fixed/random_swap.hpp
index 10717c86..3f4ae483 100644
--- a/sprout/algorithm/fixed/random_swap.hpp
+++ b/sprout/algorithm/fixed/random_swap.hpp
@@ -8,15 +8,10 @@
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
 #include <sprout/utility/forward.hpp>
+#include <sprout/utility/pair.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/swap_element.hpp>
-#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
-#	include <sprout/random/uniform_smallint.hpp>
-#	define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_smallint
-#else
-#	include <sprout/random/uniform_int_distribution.hpp>
-#	define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_int_distribution
-#endif
+#include <sprout/workaround/detail/uniform_int_distribution.hpp>
 
 namespace sprout {
 	namespace fixed {
@@ -39,7 +34,9 @@ namespace sprout {
 			make_random_swap_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) {
 				return n > 1
 					? sprout::fixed::detail::make_random_swap_indexes_1(
-						SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(sprout::forward<UniformRandomNumberGenerator>(g))
+						SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(
+							sprout::forward<UniformRandomNumberGenerator>(g)
+							)
 						)
 					: sprout::array<std::ptrdiff_t, 2>{{}}
 					;
@@ -88,6 +85,4 @@ namespace sprout {
 	using sprout::fixed::random_swap;
 }	// namespace sprout
 
-#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
-
 #endif	// #ifndef SPROUT_ALGORITHM_FIXED_RANDOM_SWAP_HPP
diff --git a/sprout/algorithm/fixed/random_swap_result.hpp b/sprout/algorithm/fixed/random_swap_result.hpp
index 19d320dc..f557fc94 100644
--- a/sprout/algorithm/fixed/random_swap_result.hpp
+++ b/sprout/algorithm/fixed/random_swap_result.hpp
@@ -10,39 +10,25 @@
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
 #include <sprout/utility/forward.hpp>
+#include <sprout/utility/pair.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/swap_element.hpp>
-#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
-#	include <sprout/random/uniform_smallint.hpp>
-#	define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_smallint
-#else
-#	include <sprout/random/uniform_int_distribution.hpp>
-#	define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_int_distribution
-#endif
+#include <sprout/workaround/detail/uniform_int_distribution.hpp>
 
 namespace sprout {
 	namespace fixed {
 		namespace detail {
 			template<typename UniformRandomNumberGenerator, typename Random>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				sprout::array<std::ptrdiff_t, 2>,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
+			inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type>
 			make_random_swap_result_indexes_2(Random const& rnd, std::ptrdiff_t i0) {
-				typedef sprout::tuples::tuple<
-					sprout::array<std::ptrdiff_t, 2>,
-					typename std::decay<UniformRandomNumberGenerator>::type
-				> result_type;
+				typedef sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
 				return result_type(
 					sprout::array<std::ptrdiff_t, 2>{{i0, rnd.result()}},
 					rnd.engine()
 					);
 			}
 			template<typename UniformRandomNumberGenerator, typename Random>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				sprout::array<std::ptrdiff_t, 2>,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
+			inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type>
 			make_random_swap_result_indexes_1(Random const& rnd) {
 				return sprout::fixed::detail::make_random_swap_result_indexes_2<UniformRandomNumberGenerator>(
 					rnd(),
@@ -50,18 +36,14 @@ namespace sprout {
 					);
 			}
 			template<typename UniformRandomNumberGenerator>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				sprout::array<std::ptrdiff_t, 2>,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
+			inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type>
 			make_random_swap_result_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) {
-				typedef sprout::tuples::tuple<
-					sprout::array<std::ptrdiff_t, 2>,
-					typename std::decay<UniformRandomNumberGenerator>::type
-				> result_type;
+				typedef sprout::pair<sprout::array<std::ptrdiff_t, 2>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
 				return n > 1
 					? sprout::fixed::detail::make_random_swap_result_indexes_1<UniformRandomNumberGenerator>(
-						SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(sprout::forward<UniformRandomNumberGenerator>(g))
+						SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(
+							sprout::forward<UniformRandomNumberGenerator>(g)
+							)
 						)
 					: result_type(
 						sprout::array<std::ptrdiff_t, 2>{{}},
@@ -70,35 +52,23 @@ namespace sprout {
 					;
 			}
 			template<typename UniformRandomNumberGenerator, typename Container, typename RandomSwapped>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				typename sprout::fixed::result_of::algorithm<Container>::type,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
 			random_swap_result_impl_1(Container const& cont, RandomSwapped const& random_swapped) {
-				typedef sprout::tuples::tuple<
-					typename sprout::fixed::result_of::algorithm<Container>::type,
-					typename std::decay<UniformRandomNumberGenerator>::type
-				> result_type;
-				return sprout::tuples::get<0>(random_swapped)[0] == sprout::tuples::get<0>(random_swapped)[1]
-					? result_type(
-						sprout::deep_copy(cont),
-						sprout::tuples::get<1>(random_swapped)
-						)
+				typedef typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type result_type;
+				return sprout::first(random_swapped)[0] == sprout::first(random_swapped)[1]
+					? result_type(sprout::deep_copy(cont), sprout::second(random_swapped))
 					: result_type(
 						sprout::fixed::swap_element(
 							cont,
-							sprout::next(sprout::begin(cont), sprout::tuples::get<0>(random_swapped)[0]),
-							sprout::next(sprout::begin(cont), sprout::tuples::get<0>(random_swapped)[1])
+							sprout::next(sprout::begin(cont), sprout::first(random_swapped)[0]),
+							sprout::next(sprout::begin(cont), sprout::first(random_swapped)[1])
 							),
-						sprout::tuples::get<1>(random_swapped)
+						sprout::second(random_swapped)
 						)
 					;
 			}
 			template<typename Container, typename UniformRandomNumberGenerator>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				typename sprout::fixed::result_of::algorithm<Container>::type,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
 			random_swap_result_impl(
 				Container const& cont, UniformRandomNumberGenerator&& g,
 				typename sprout::container_traits<Container>::size_type size
@@ -117,10 +87,7 @@ namespace sprout {
 		// random_swap_result
 		//
 		template<typename Container, typename UniformRandomNumberGenerator>
-		inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-			typename sprout::fixed::result_of::algorithm<Container>::type,
-			typename std::decay<UniformRandomNumberGenerator>::type
-		>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
 		random_swap_result(Container const& cont, UniformRandomNumberGenerator&& g) {
 			return sprout::fixed::detail::random_swap_result_impl(
 				cont, sprout::forward<UniformRandomNumberGenerator>(g),
@@ -132,6 +99,4 @@ namespace sprout {
 	using sprout::fixed::random_swap_result;
 }	// namespace sprout
 
-#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
-
 #endif	// #ifndef SPROUT_ALGORITHM_FIXED_RANDOM_SWAP_RESULT_HPP
diff --git a/sprout/algorithm/fixed/result_of.hpp b/sprout/algorithm/fixed/result_of.hpp
index a0bd6ef8..4f99b50e 100644
--- a/sprout/algorithm/fixed/result_of.hpp
+++ b/sprout/algorithm/fixed/result_of.hpp
@@ -1,8 +1,10 @@
 #ifndef SPROUT_ALGORITHM_FIXED_RESULT_OF_HPP
 #define SPROUT_ALGORITHM_FIXED_RESULT_OF_HPP
 
+#include <type_traits>
 #include <sprout/config.hpp>
 #include <sprout/container/traits.hpp>
+#include <sprout/utility/pair.hpp>
 
 namespace sprout {
 	namespace fixed {
@@ -15,11 +17,24 @@ namespace sprout {
 			public:
 				typedef typename sprout::container_construct_traits<Result>::copied_type type;
 			};
+
+			//
+			// shuffle
+			//
+			template<typename Container, typename UniformRandomNumberGenerator>
+			struct shuffle {
+			public:
+				typedef sprout::pair<
+					typename sprout::fixed::result_of::algorithm<Container>::type,
+					typename std::decay<UniformRandomNumberGenerator>::type
+				> type;
+			};
 		}	// namespace result_of
 	}	// namespace fixed
 
 	namespace result_of {
 		using sprout::fixed::result_of::algorithm;
+		using sprout::fixed::result_of::shuffle;
 	}	// namespace result_of
 }	// namespace sprout
 
diff --git a/sprout/algorithm/fixed/shuffle.hpp b/sprout/algorithm/fixed/shuffle.hpp
index d2a5d54c..10f10598 100644
--- a/sprout/algorithm/fixed/shuffle.hpp
+++ b/sprout/algorithm/fixed/shuffle.hpp
@@ -13,13 +13,7 @@
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/swap_element.hpp>
 #include <sprout/numeric/fixed/iota.hpp>
-#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
-#	include <sprout/random/uniform_smallint.hpp>
-#	define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_smallint
-#else
-#	include <sprout/random/uniform_int_distribution.hpp>
-#	define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_int_distribution
-#endif
+#include <sprout/workaround/detail/uniform_int_distribution.hpp>
 
 namespace sprout {
 	namespace fixed {
@@ -43,7 +37,9 @@ namespace sprout {
 				return n > 1
 					? sprout::fixed::detail::make_shuffle_indexes_1(
 						n,
-						SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(sprout::forward<UniformRandomNumberGenerator>(g)),
+						SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(
+							sprout::forward<UniformRandomNumberGenerator>(g)
+							),
 						sprout::fixed::iota(sprout::pit<sprout::array<std::ptrdiff_t, N> >(), 0),
 						0
 						)
@@ -110,6 +106,4 @@ namespace sprout {
 	using sprout::fixed::shuffle;
 }	// namespace sprout
 
-#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
-
 #endif	// #ifndef SPROUT_ALGORITHM_FIXED_SHUFFLE_HPP
diff --git a/sprout/algorithm/fixed/shuffle_result.hpp b/sprout/algorithm/fixed/shuffle_result.hpp
index 2fd850d2..87b252f7 100644
--- a/sprout/algorithm/fixed/shuffle_result.hpp
+++ b/sprout/algorithm/fixed/shuffle_result.hpp
@@ -7,35 +7,23 @@
 #include <sprout/index_tuple.hpp>
 #include <sprout/array.hpp>
 #include <sprout/pit.hpp>
-#include <sprout/tuple/tuple.hpp>
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
 #include <sprout/utility/forward.hpp>
+#include <sprout/utility/pair.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/swap_element.hpp>
 #include <sprout/numeric/fixed/iota.hpp>
-#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
-#	include <sprout/random/uniform_smallint.hpp>
-#	define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_smallint
-#else
-#	include <sprout/random/uniform_int_distribution.hpp>
-#	define SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_int_distribution
-#endif
+#include <sprout/workaround/detail/uniform_int_distribution.hpp>
 
 namespace sprout {
 	namespace fixed {
 		namespace detail {
 			template<typename UniformRandomNumberGenerator, std::size_t N, typename Random>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				sprout::array<std::ptrdiff_t, N>,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
+			inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type>
 			make_shuffle_result_indexes_1(std::ptrdiff_t n, Random const& rnd, sprout::array<std::ptrdiff_t, N> const& arr, std::ptrdiff_t i) {
-				typedef sprout::tuples::tuple<
-					sprout::array<std::ptrdiff_t, N>,
-					typename std::decay<UniformRandomNumberGenerator>::type
-				> result_type;
+				typedef sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
 				return i < n - 1
 					? sprout::fixed::detail::make_shuffle_result_indexes_1<UniformRandomNumberGenerator>(
 						n,
@@ -50,19 +38,15 @@ namespace sprout {
 					;
 			}
 			template<std::size_t N, typename UniformRandomNumberGenerator>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				sprout::array<std::ptrdiff_t, N>,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
+			inline SPROUT_CONSTEXPR sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type>
 			make_shuffle_result_indexes(std::ptrdiff_t n, UniformRandomNumberGenerator&& g) {
-				typedef sprout::tuples::tuple<
-					sprout::array<std::ptrdiff_t, N>,
-					typename std::decay<UniformRandomNumberGenerator>::type
-				> result_type;
+				typedef sprout::pair<sprout::array<std::ptrdiff_t, N>, typename std::decay<UniformRandomNumberGenerator>::type> result_type;
 				return n > 1
 					? sprout::fixed::detail::make_shuffle_result_indexes_1<UniformRandomNumberGenerator>(
 						n,
-						SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(sprout::forward<UniformRandomNumberGenerator>(g)),
+						SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION<std::ptrdiff_t>(0, n - 1)(
+							sprout::forward<UniformRandomNumberGenerator>(g)
+							),
 						sprout::fixed::iota(sprout::pit<sprout::array<std::ptrdiff_t, N> >(), 0),
 						0
 						)
@@ -73,10 +57,7 @@ namespace sprout {
 					;
 			}
 			template<typename UniformRandomNumberGenerator, typename Container, typename Shuffled, sprout::index_t... Indexes>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				typename sprout::fixed::result_of::algorithm<Container>::type,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
 			shuffle_result_impl_1(
 				Container const& cont,
 				sprout::index_tuple<Indexes...>,
@@ -85,27 +66,21 @@ namespace sprout {
 				typename sprout::container_traits<Container>::size_type size
 				)
 			{
-				typedef sprout::tuples::tuple<
-					typename sprout::fixed::result_of::algorithm<Container>::type,
-					typename std::decay<UniformRandomNumberGenerator>::type
-				> result_type;
+				typedef typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type result_type;
 				return result_type(
 					sprout::remake<Container>(
 						cont,
 						sprout::size(cont),
 						(Indexes >= offset && Indexes < offset + size
-							? *sprout::next(sprout::begin(cont), sprout::tuples::get<0>(shuffled)[Indexes - offset])
+							? *sprout::next(sprout::begin(cont), sprout::first(shuffled)[Indexes - offset])
 							: *sprout::next(sprout::internal_begin(cont), Indexes)
 							)...
 						),
-						sprout::tuples::get<1>(shuffled)
+						sprout::second(shuffled)
 					);
 			}
 			template<typename Container, typename UniformRandomNumberGenerator, sprout::index_t... Indexes>
-			inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-				typename sprout::fixed::result_of::algorithm<Container>::type,
-				typename std::decay<UniformRandomNumberGenerator>::type
-			>
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
 			shuffle_result_impl(
 				Container const& cont,
 				sprout::index_tuple<Indexes...> indexes,
@@ -130,10 +105,7 @@ namespace sprout {
 		// shuffle_result
 		//
 		template<typename Container, typename UniformRandomNumberGenerator>
-		inline SPROUT_CONSTEXPR sprout::tuples::tuple<
-			typename sprout::fixed::result_of::algorithm<Container>::type,
-			typename std::decay<UniformRandomNumberGenerator>::type
-		>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::shuffle<Container, UniformRandomNumberGenerator>::type
 		shuffle_result(Container const& cont, UniformRandomNumberGenerator&& g) {
 			return sprout::fixed::detail::shuffle_result_impl(
 				cont,
@@ -148,6 +120,4 @@ namespace sprout {
 	using sprout::fixed::shuffle_result;
 }	// namespace sprout
 
-#undef SPROUT_WORKAROUND_UNIFORM_INT_DISTRIBUTION
-
 #endif	// #ifndef SPROUT_ALGORITHM_FIXED_SHUFFLE_RESULT_HPP
diff --git a/sprout/bitset/bitwise.hpp b/sprout/bitset/bitwise.hpp
index 3e3655ce..a0025c89 100644
--- a/sprout/bitset/bitwise.hpp
+++ b/sprout/bitset/bitwise.hpp
@@ -9,17 +9,17 @@ namespace sprout {
 	// 20.5.4 bitset operators:
 
 	template<std::size_t N>
-	inline SPROUT_CONSTEXPR bitset<N>
+	inline SPROUT_CONSTEXPR sprout::bitset<N>
 	operator&(sprout::bitset<N> const& lhs, sprout::bitset<N> const& rhs) SPROUT_NOEXCEPT {
 		return sprout::bitset<N>(lhs.do_and(rhs));
 	}
 	template<std::size_t N>
-	inline SPROUT_CONSTEXPR bitset<N>
+	inline SPROUT_CONSTEXPR sprout::bitset<N>
 	operator|(sprout::bitset<N> const& lhs, sprout::bitset<N> const& rhs) SPROUT_NOEXCEPT {
 		return sprout::bitset<N>(lhs.do_or(rhs));
 	}
 	template<std::size_t N>
-	inline SPROUT_CONSTEXPR bitset<N>
+	inline SPROUT_CONSTEXPR sprout::bitset<N>
 	operator^(sprout::bitset<N> const& lhs, sprout::bitset<N> const& rhs) SPROUT_NOEXCEPT {
 		return sprout::bitset<N>(lhs.do_xor(rhs));
 	}
diff --git a/sprout/brainfuck/brainfuck.hpp b/sprout/brainfuck/brainfuck.hpp
index 8b4317c0..70ff6c52 100644
--- a/sprout/brainfuck/brainfuck.hpp
+++ b/sprout/brainfuck/brainfuck.hpp
@@ -57,17 +57,17 @@ namespace sprout {
 			}
 
 			template<
-				typename SourceBidirectionalIterator, typename Output, typename InputInputIterator,
+				typename BidirectionalIteratorSource, typename Output, typename InputIteratorInput,
 				typename Buffer, typename OutputBuffer
 			>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
 			exec_impl(
-				SourceBidirectionalIterator first, SourceBidirectionalIterator last,
-				Output const& output, InputInputIterator in_first, InputInputIterator in_last,
+				BidirectionalIteratorSource first, BidirectionalIteratorSource last,
+				Output const& output, InputIteratorInput in_first, InputIteratorInput in_last,
 				Buffer const& buffer, OutputBuffer const& out_buffer, std::size_t pos = 0, std::size_t out_pos = 0
 				)
 			{
-				typedef typename std::iterator_traits<SourceBidirectionalIterator>::value_type value_type;
+				typedef typename std::iterator_traits<BidirectionalIteratorSource>::value_type value_type;
 				typedef typename sprout::container_traits<OutputBuffer>::value_type out_value_type;
 				return first == last
 					? sprout::fixed::copy(
@@ -136,41 +136,41 @@ namespace sprout {
 		//
 		// exec
 		//
-		template<std::size_t BufferSize = 32, typename SourceBidirectionalIterator, typename Output, typename InputInputIterator>
+		template<std::size_t BufferSize = 32, typename BidirectionalIteratorSource, typename Output, typename InputIteratorInput>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
 		exec(
-			SourceBidirectionalIterator first, SourceBidirectionalIterator last,
-			Output const& output, InputInputIterator in_first, InputInputIterator in_last
+			BidirectionalIteratorSource first, BidirectionalIteratorSource last,
+			Output const& output, InputIteratorInput in_first, InputIteratorInput in_last
 			)
 		{
-			typedef typename std::iterator_traits<SourceBidirectionalIterator>::value_type value_type;
+			typedef typename std::iterator_traits<BidirectionalIteratorSource>::value_type value_type;
 			typedef sprout::container_traits<Output> out_traits;
 			return sprout::brainfuck::detail::exec_impl(
 				first, last, output, in_first, in_last,
 				sprout::array<value_type, BufferSize>{{}}, sprout::array<typename out_traits::value_type, out_traits::static_size>{{}}
 				);
 		}
-		template<std::size_t BufferSize = 32, typename SourceBidirectionalIterator, typename Output>
+		template<std::size_t BufferSize = 32, typename BidirectionalIteratorSource, typename Output>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
 		exec(
-			SourceBidirectionalIterator first, SourceBidirectionalIterator last,
+			BidirectionalIteratorSource first, BidirectionalIteratorSource last,
 			Output const& output
 			)
 		{
-			typedef typename std::iterator_traits<SourceBidirectionalIterator>::value_type value_type;
+			typedef typename std::iterator_traits<BidirectionalIteratorSource>::value_type value_type;
 			return sprout::brainfuck::exec<BufferSize>(
 				first, last, output, sprout::value_iterator<value_type>(value_type()), sprout::value_iterator<value_type>()
 				);
 		}
-		template<std::size_t BufferSize = 32, typename SourceBidirectionalIterator>
+		template<std::size_t BufferSize = 32, typename BidirectionalIteratorSource>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<
-			sprout::array<typename std::iterator_traits<SourceBidirectionalIterator>::value_type, BufferSize>
+			sprout::array<typename std::iterator_traits<BidirectionalIteratorSource>::value_type, BufferSize>
 		>::type
 		exec(
-			SourceBidirectionalIterator first, SourceBidirectionalIterator last
+			BidirectionalIteratorSource first, BidirectionalIteratorSource last
 			)
 		{
-			typedef typename std::iterator_traits<SourceBidirectionalIterator>::value_type value_type;
+			typedef typename std::iterator_traits<BidirectionalIteratorSource>::value_type value_type;
 			return sprout::brainfuck::exec<BufferSize>(
 				first, last, sprout::pit<sprout::array<value_type, BufferSize> >()
 				);
@@ -179,25 +179,25 @@ namespace sprout {
 		//
 		// exec_range
 		//
-		template<std::size_t BufferSize = 32, typename Source, typename Output, typename Input>
+		template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output, typename InputRangeInput>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
-		exec_range(Source const& source, Output const& output, Input const& input) {
+		exec_range(BidirectionalRangeSource const& source, Output const& output, InputRangeInput const& input) {
 			return sprout::brainfuck::exec<BufferSize>(
 				sprout::begin(source), sprout::end(source), output, sprout::begin(input), sprout::end(input)
 				);
 		}
-		template<std::size_t BufferSize = 32, typename Source, typename Output>
+		template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
-		exec_range(Source const& source, Output const& output) {
+		exec_range(BidirectionalRangeSource const& source, Output const& output) {
 			return sprout::brainfuck::exec<BufferSize>(
 				sprout::begin(source), sprout::end(source), output
 				);
 		}
-		template<std::size_t BufferSize = 32, typename Source>
+		template<std::size_t BufferSize = 32, typename BidirectionalRangeSource>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<
-			sprout::array<typename sprout::container_traits<Source>::value_type, BufferSize>
+			sprout::array<typename sprout::container_traits<BidirectionalRangeSource>::value_type, BufferSize>
 		>::type
-		exec_range(Source const& source) {
+		exec_range(BidirectionalRangeSource const& source) {
 			return sprout::brainfuck::exec<BufferSize>(
 				sprout::begin(source), sprout::end(source)
 				);
diff --git a/sprout/brainfuck/misa.hpp b/sprout/brainfuck/misa.hpp
index 495f474c..06a09ad0 100644
--- a/sprout/brainfuck/misa.hpp
+++ b/sprout/brainfuck/misa.hpp
@@ -57,30 +57,30 @@ namespace sprout {
 			//
 			// exec_range
 			//
-			template<std::size_t BufferSize = 32, typename Source, typename Output, typename Input>
+			template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output, typename InputRangeInput>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
-			exec_range(Source const& source, Output const& output, Input const& input) {
-				typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
+			exec_range(BidirectionalRangeSource const& source, Output const& output, InputRangeInput const& input) {
+				typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
 				return sprout::brainfuck::exec_range<BufferSize>(
 					sprout::brainfuck::misa::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
 					output, input
 					);
 			}
-			template<std::size_t BufferSize = 32, typename Source, typename Output>
+			template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
-			exec_range(Source const& source, Output const& output) {
-				typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
+			exec_range(BidirectionalRangeSource const& source, Output const& output) {
+				typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
 				return sprout::brainfuck::exec_range<BufferSize>(
 					sprout::brainfuck::misa::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
 					output
 					);
 			}
-			template<std::size_t BufferSize = 32, typename Source>
+			template<std::size_t BufferSize = 32, typename BidirectionalRangeSource>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<
-				sprout::array<typename sprout::container_traits<Source>::value_type, BufferSize>
+				sprout::array<typename sprout::container_traits<BidirectionalRangeSource>::value_type, BufferSize>
 			>::type
-			exec_range(Source const& source) {
-				typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
+			exec_range(BidirectionalRangeSource const& source) {
+				typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
 				return sprout::brainfuck::exec_range<BufferSize>(
 					sprout::brainfuck::misa::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first
 					);
diff --git a/sprout/brainfuck/ook.hpp b/sprout/brainfuck/ook.hpp
index 75a6692b..e4a23cbf 100644
--- a/sprout/brainfuck/ook.hpp
+++ b/sprout/brainfuck/ook.hpp
@@ -57,30 +57,30 @@ namespace sprout {
 			//
 			// exec_range
 			//
-			template<std::size_t BufferSize = 32, typename Source, typename Output, typename Input>
+			template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output, typename InputRangeInput>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
-			exec_range(Source const& source, Output const& output, Input const& input) {
-				typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
+			exec_range(BidirectionalRangeSource const& source, Output const& output, InputRangeInput const& input) {
+				typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
 				return sprout::brainfuck::exec_range<BufferSize>(
 					sprout::brainfuck::ook::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
 					output, input
 					);
 			}
-			template<std::size_t BufferSize = 32, typename Source, typename Output>
+			template<std::size_t BufferSize = 32, typename BidirectionalRangeSource, typename Output>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Output>::type
-			exec_range(Source const& source, Output const& output) {
-				typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
+			exec_range(BidirectionalRangeSource const& source, Output const& output) {
+				typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
 				return sprout::brainfuck::exec_range<BufferSize>(
 					sprout::brainfuck::ook::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first,
 					output
 					);
 			}
-			template<std::size_t BufferSize = 32, typename Source>
+			template<std::size_t BufferSize = 32, typename BidirectionalRangeSource>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<
-				sprout::array<typename sprout::container_traits<Source>::value_type, BufferSize>
+				sprout::array<typename sprout::container_traits<BidirectionalRangeSource>::value_type, BufferSize>
 			>::type
-			exec_range(Source const& source) {
-				typedef typename sprout::container_construct_traits<Source>::copied_type copied_type;
+			exec_range(BidirectionalRangeSource const& source) {
+				typedef typename sprout::container_construct_traits<BidirectionalRangeSource>::copied_type copied_type;
 				return sprout::brainfuck::exec_range<BufferSize>(
 					sprout::brainfuck::ook::to_brainfuck(sprout::begin(source), sprout::end(source), sprout::pit<copied_type>()).first
 					);
diff --git a/sprout/range/adaptor/detail/jointed_range_default.hpp b/sprout/range/adaptor/detail/jointed_range_default.hpp
index 90ed4c35..63ce2396 100644
--- a/sprout/range/adaptor/detail/jointed_range_default.hpp
+++ b/sprout/range/adaptor/detail/jointed_range_default.hpp
@@ -142,9 +142,11 @@ namespace sprout {
 				>::type
 			> {
 			public:
-				typedef typename sprout::containers::weak_rebind_size<
-					typename sprout::container_construct_traits<LRange>::copied_type,
-					sprout::adaptors::detail::jointed_range_size<LRange, RRange>::static_size
+				typedef typename sprout::container_construct_traits<
+					typename sprout::containers::weak_rebind_size<
+						typename sprout::container_construct_traits<LRange>::copied_type,
+						sprout::adaptors::detail::jointed_range_size<LRange, RRange>::static_size
+					>::type
 				>::type copied_type;
 			};
 
diff --git a/sprout/range/algorithm/fit/clamp_range_copy.hpp b/sprout/range/algorithm/fit/clamp_range_copy.hpp
index f5ea0e5f..2e171c6a 100644
--- a/sprout/range/algorithm/fit/clamp_range_copy.hpp
+++ b/sprout/range/algorithm/fit/clamp_range_copy.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// clamp_range_copy
 			//
-			template<typename Input, typename Result, typename Compare>
+			template<typename InputRange, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
 			clamp_range_copy(
-				Input const& input, Result const& result,
-				typename sprout::container_traits<Input>::value_type const& low,
-				typename sprout::container_traits<Input>::value_type const& high,
+				InputRange const& rng, Result const& result,
+				typename sprout::container_traits<InputRange>::value_type const& low,
+				typename sprout::container_traits<InputRange>::value_type const& high,
 				Compare comp
 				)
 			{
-				return sprout::fit::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high, comp);
+				return sprout::fit::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high, comp);
 			}
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
 			clamp_range_copy(
-				Input const& input, Result const& result,
-				typename sprout::container_traits<Input>::value_type const& low,
-				typename sprout::container_traits<Input>::value_type const& high
+				InputRange const& rng, Result const& result,
+				typename sprout::container_traits<InputRange>::value_type const& low,
+				typename sprout::container_traits<InputRange>::value_type const& high
 				)
 			{
-				return sprout::fit::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high);
+				return sprout::fit::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/copy.hpp b/sprout/range/algorithm/fit/copy.hpp
index fd4987c4..c72d3617 100644
--- a/sprout/range/algorithm/fit/copy.hpp
+++ b/sprout/range/algorithm/fit/copy.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// copy
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			copy(Input const& input, Result const& result) {
-				return sprout::fit::copy(sprout::begin(input), sprout::end(input), result);
+			copy(InputRange const& rng, Result const& result) {
+				return sprout::fit::copy(sprout::begin(rng), sprout::end(rng), result);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/copy_backward.hpp b/sprout/range/algorithm/fit/copy_backward.hpp
index 2012ead6..f819f369 100644
--- a/sprout/range/algorithm/fit/copy_backward.hpp
+++ b/sprout/range/algorithm/fit/copy_backward.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// copy_backward
 			//
-			template<typename Input, typename Result>
+			template<typename BidirectionalRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			copy_backward(Input const& input, Result const& result) {
-				return sprout::fit::copy_backward(sprout::begin(input), sprout::end(input), result);
+			copy_backward(BidirectionalRange const& rng, Result const& result) {
+				return sprout::fit::copy_backward(sprout::begin(rng), sprout::end(rng), result);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/copy_if.hpp b/sprout/range/algorithm/fit/copy_if.hpp
index d78ee42f..bb62a465 100644
--- a/sprout/range/algorithm/fit/copy_if.hpp
+++ b/sprout/range/algorithm/fit/copy_if.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// copy_if
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename InputRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			copy_if(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fit::copy_if(sprout::begin(input), sprout::end(input), result, pred);
+			copy_if(InputRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fit::copy_if(sprout::begin(rng), sprout::end(rng), result, pred);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/copy_until.hpp b/sprout/range/algorithm/fit/copy_until.hpp
index 03444fb4..a13dec36 100644
--- a/sprout/range/algorithm/fit/copy_until.hpp
+++ b/sprout/range/algorithm/fit/copy_until.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// copy_until
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename InputRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			copy_until(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fit::copy_until(sprout::begin(input), sprout::end(input), result, pred);
+			copy_until(InputRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fit::copy_until(sprout::begin(rng), sprout::end(rng), result, pred);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/copy_while.hpp b/sprout/range/algorithm/fit/copy_while.hpp
index 58d6b814..266af2f6 100644
--- a/sprout/range/algorithm/fit/copy_while.hpp
+++ b/sprout/range/algorithm/fit/copy_while.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// copy_while
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename InputRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			copy_while(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fit::copy_while(sprout::begin(input), sprout::end(input), result, pred);
+			copy_while(InputRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fit::copy_while(sprout::begin(rng), sprout::end(rng), result, pred);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/merge.hpp b/sprout/range/algorithm/fit/merge.hpp
index 439ac8da..1dab87cc 100644
--- a/sprout/range/algorithm/fit/merge.hpp
+++ b/sprout/range/algorithm/fit/merge.hpp
@@ -13,15 +13,15 @@ namespace sprout {
 			//
 			// merge
 			//
-			template<typename Input1, typename Input2, typename Result, typename Compare>
+			template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			merge(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
-				return sprout::fit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
+			merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
+				return sprout::fit::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
 			}
-			template<typename Input1, typename Input2, typename Result>
+			template<typename InputRange1, typename InputRange2, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			merge(Input1 const& input1, Input2 const& input2, Result const& result) {
-				return sprout::fit::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
+			merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
+				return sprout::fit::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/partition_copy.hpp b/sprout/range/algorithm/fit/partition_copy.hpp
index e0962c6e..b05e5b10 100644
--- a/sprout/range/algorithm/fit/partition_copy.hpp
+++ b/sprout/range/algorithm/fit/partition_copy.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// partition_copy
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename InputRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			partition_copy(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fit::partition_copy(sprout::begin(input), sprout::end(input), result, pred);
+			partition_copy(InputRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fit::partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/remove_copy.hpp b/sprout/range/algorithm/fit/remove_copy.hpp
index 627bd5cc..2482366d 100644
--- a/sprout/range/algorithm/fit/remove_copy.hpp
+++ b/sprout/range/algorithm/fit/remove_copy.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// remove_copy
 			//
-			template<typename Input, typename Result, typename T>
+			template<typename InputRange, typename Result, typename T>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			remove_copy(Input const& input, Result const& result, T const& value) {
-				return sprout::fit::remove_copy(sprout::begin(input), sprout::end(input), result, value);
+			remove_copy(InputRange const& rng, Result const& result, T const& value) {
+				return sprout::fit::remove_copy(sprout::begin(rng), sprout::end(rng), result, value);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/remove_copy_if.hpp b/sprout/range/algorithm/fit/remove_copy_if.hpp
index 5da154b3..9733daca 100644
--- a/sprout/range/algorithm/fit/remove_copy_if.hpp
+++ b/sprout/range/algorithm/fit/remove_copy_if.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// remove_copy_if
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename InputRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			remove_copy_if(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fit::remove_copy_if(sprout::begin(input), sprout::end(input), result, pred);
+			remove_copy_if(InputRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fit::remove_copy_if(sprout::begin(rng), sprout::end(rng), result, pred);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/replace_copy.hpp b/sprout/range/algorithm/fit/replace_copy.hpp
index 357c7390..7271f5b9 100644
--- a/sprout/range/algorithm/fit/replace_copy.hpp
+++ b/sprout/range/algorithm/fit/replace_copy.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// replace_copy
 			//
-			template<typename Input, typename Result, typename T>
+			template<typename InputRange, typename Result, typename T>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			replace_copy(Input const& input, Result const& result, T const& old_value, T const& new_value) {
-				return sprout::fit::replace_copy(sprout::begin(input), sprout::end(input), result, old_value, new_value);
+			replace_copy(InputRange const& rng, Result const& result, T const& old_value, T const& new_value) {
+				return sprout::fit::replace_copy(sprout::begin(rng), sprout::end(rng), result, old_value, new_value);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/replace_copy_if.hpp b/sprout/range/algorithm/fit/replace_copy_if.hpp
index ace2adc1..41f64432 100644
--- a/sprout/range/algorithm/fit/replace_copy_if.hpp
+++ b/sprout/range/algorithm/fit/replace_copy_if.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// replace_copy_if
 			//
-			template<typename Input, typename Result, typename T, typename Predicate>
+			template<typename InputRange, typename Result, typename T, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			replace_copy_if(Input const& input, Result const& result, Predicate pred, T const& new_value) {
-				return sprout::fit::replace_copy_if(sprout::begin(input), sprout::end(input), result, pred, new_value);
+			replace_copy_if(InputRange const& rng, Result const& result, Predicate pred, T const& new_value) {
+				return sprout::fit::replace_copy_if(sprout::begin(rng), sprout::end(rng), result, pred, new_value);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/reverse_copy.hpp b/sprout/range/algorithm/fit/reverse_copy.hpp
index fa9b5c77..e8b66e51 100644
--- a/sprout/range/algorithm/fit/reverse_copy.hpp
+++ b/sprout/range/algorithm/fit/reverse_copy.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// reverse_copy
 			//
-			template<typename Input, typename Result>
+			template<typename BidirectionalRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			reverse_copy(Input const& input, Result const& result) {
-				return sprout::fit::reverse_copy(sprout::begin(input), sprout::end(input), result);
+			reverse_copy(BidirectionalRange const& rng, Result const& result) {
+				return sprout::fit::reverse_copy(sprout::begin(rng), sprout::end(rng), result);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/rotate_copy.hpp b/sprout/range/algorithm/fit/rotate_copy.hpp
index b4b77b21..26150d67 100644
--- a/sprout/range/algorithm/fit/rotate_copy.hpp
+++ b/sprout/range/algorithm/fit/rotate_copy.hpp
@@ -13,14 +13,14 @@ namespace sprout {
 			//
 			// rotate_copy
 			//
-			template<typename Input, typename Result>
+			template<typename ForwardRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
 			rotate_copy(
-				Input const& input, typename sprout::container_traits<Input>::const_iterator middle,
+				ForwardRange const& rng, typename sprout::container_traits<ForwardRange>::const_iterator middle,
 				Result const& result
 				)
 			{
-				return sprout::fit::rotate_copy(sprout::begin(input), middle, sprout::end(input), result);
+				return sprout::fit::rotate_copy(sprout::begin(rng), middle, sprout::end(rng), result);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/set_difference.hpp b/sprout/range/algorithm/fit/set_difference.hpp
index 38f99608..5d3111d8 100644
--- a/sprout/range/algorithm/fit/set_difference.hpp
+++ b/sprout/range/algorithm/fit/set_difference.hpp
@@ -13,15 +13,15 @@ namespace sprout {
 			//
 			// set_difference
 			//
-			template<typename Input1, typename Input2, typename Result, typename Compare>
+			template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
-				return sprout::fit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
+			set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
+				return sprout::fit::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
 			}
-			template<typename Input1, typename Input2, typename Result>
+			template<typename InputRange1, typename InputRange2, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
-				return sprout::fit::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
+			set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
+				return sprout::fit::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/set_intersection.hpp b/sprout/range/algorithm/fit/set_intersection.hpp
index cc74f2c8..ac23b03c 100644
--- a/sprout/range/algorithm/fit/set_intersection.hpp
+++ b/sprout/range/algorithm/fit/set_intersection.hpp
@@ -13,15 +13,15 @@ namespace sprout {
 			//
 			// set_intersection
 			//
-			template<typename Input1, typename Input2, typename Result, typename Compare>
+			template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_intersection(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
-				return sprout::fit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
+			set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
+				return sprout::fit::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
 			}
-			template<typename Input1, typename Input2, typename Result>
+			template<typename InputRange1, typename InputRange2, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_intersection(Input1 const& input1, Input2 const& input2, Result const& result) {
-				return sprout::fit::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
+			set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
+				return sprout::fit::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/set_symmetric_difference.hpp b/sprout/range/algorithm/fit/set_symmetric_difference.hpp
index 9df589d2..af36de9e 100644
--- a/sprout/range/algorithm/fit/set_symmetric_difference.hpp
+++ b/sprout/range/algorithm/fit/set_symmetric_difference.hpp
@@ -13,15 +13,15 @@ namespace sprout {
 			//
 			// set_symmetric_difference
 			//
-			template<typename Input1, typename Input2, typename Result, typename Compare>
+			template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
-				return sprout::fit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
+			set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
+				return sprout::fit::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
 			}
-			template<typename Input1, typename Input2, typename Result>
+			template<typename InputRange1, typename InputRange2, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
-				return sprout::fit::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
+			set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
+				return sprout::fit::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/set_union.hpp b/sprout/range/algorithm/fit/set_union.hpp
index 2ad61c2a..d4c0f345 100644
--- a/sprout/range/algorithm/fit/set_union.hpp
+++ b/sprout/range/algorithm/fit/set_union.hpp
@@ -13,15 +13,15 @@ namespace sprout {
 			//
 			// set_union
 			//
-			template<typename Input1, typename Input2, typename Result, typename Compare>
+			template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_union(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
-				return sprout::fit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
+			set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
+				return sprout::fit::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
 			}
-			template<typename Input1, typename Input2, typename Result>
+			template<typename InputRange1, typename InputRange2, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_union(Input1 const& input1, Input2 const& input2, Result const& result) {
-				return sprout::fit::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
+			set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
+				return sprout::fit::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/stable_partition_copy.hpp b/sprout/range/algorithm/fit/stable_partition_copy.hpp
index ac495d70..7d3ded52 100644
--- a/sprout/range/algorithm/fit/stable_partition_copy.hpp
+++ b/sprout/range/algorithm/fit/stable_partition_copy.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// stable_partition_copy
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename InputRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			stable_partition_copy(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fit::stable_partition_copy(sprout::begin(input), sprout::end(input), result, pred);
+			stable_partition_copy(InputRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fit::stable_partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/swap_element_copy.hpp b/sprout/range/algorithm/fit/swap_element_copy.hpp
index 279fc806..5c36498b 100644
--- a/sprout/range/algorithm/fit/swap_element_copy.hpp
+++ b/sprout/range/algorithm/fit/swap_element_copy.hpp
@@ -13,15 +13,15 @@ namespace sprout {
 			//
 			// swap_element_copy
 			//
-			template<typename Input, typename Result>
+			template<typename ForwardRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
 			swap_element_copy(
-				Input const& input, Result const& result,
-				typename sprout::container_traits<Input>::const_iterator pos1,
-				typename sprout::container_traits<Input>::const_iterator pos2
+				ForwardRange const& rng, Result const& result,
+				typename sprout::container_traits<ForwardRange>::const_iterator pos1,
+				typename sprout::container_traits<ForwardRange>::const_iterator pos2
 				)
 			{
-				return sprout::fit::swap_element_copy(sprout::begin(input), sprout::end(input), result, pos1, pos2);
+				return sprout::fit::swap_element_copy(sprout::begin(rng), sprout::end(rng), result, pos1, pos2);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fit/transform.hpp b/sprout/range/algorithm/fit/transform.hpp
index 757fc8f3..bcd738ba 100644
--- a/sprout/range/algorithm/fit/transform.hpp
+++ b/sprout/range/algorithm/fit/transform.hpp
@@ -13,10 +13,10 @@ namespace sprout {
 			//
 			// transform
 			//
-			template<typename Input, typename Result, typename UnaryOperation>
+			template<typename InputRange, typename Result, typename UnaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			transform(Input const& input, Result const& result, UnaryOperation op) {
-				return sprout::fit::transform(sprout::begin(input), sprout::end(input), result, op);
+			transform(InputRange const& rng, Result const& result, UnaryOperation op) {
+				return sprout::fit::transform(sprout::begin(rng), sprout::end(rng), result, op);
 			}
 			template<typename Input1, typename Input2, typename Result, typename BinaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
diff --git a/sprout/range/algorithm/fit/unique_copy.hpp b/sprout/range/algorithm/fit/unique_copy.hpp
index 75dfaceb..fe794d54 100644
--- a/sprout/range/algorithm/fit/unique_copy.hpp
+++ b/sprout/range/algorithm/fit/unique_copy.hpp
@@ -13,15 +13,15 @@ namespace sprout {
 			//
 			// unique_copy
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			unique_copy(Input const& input, Result const& result) {
-				return sprout::fit::unique_copy(sprout::begin(input), sprout::end(input), result);
+			unique_copy(InputRange const& rng, Result const& result) {
+				return sprout::fit::unique_copy(sprout::begin(rng), sprout::end(rng), result);
 			}
-			template<typename Input, typename Result, typename BinaryPredicate>
+			template<typename InputRange, typename Result, typename BinaryPredicate>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			unique_copy(Input const& input, Result const& result, BinaryPredicate pred) {
-				return sprout::fit::unique_copy(sprout::begin(input), sprout::end(input), result, pred);
+			unique_copy(InputRange const& rng, Result const& result, BinaryPredicate pred) {
+				return sprout::fit::unique_copy(sprout::begin(rng), sprout::end(rng), result, pred);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/algorithm/fixed/clamp_range_copy.hpp b/sprout/range/algorithm/fixed/clamp_range_copy.hpp
index 1b153e16..88acf614 100644
--- a/sprout/range/algorithm/fixed/clamp_range_copy.hpp
+++ b/sprout/range/algorithm/fixed/clamp_range_copy.hpp
@@ -13,48 +13,48 @@ namespace sprout {
 			//
 			// clamp_range_copy
 			//
-			template<typename Input, typename Result, typename Compare>
+			template<typename InputRange, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 			clamp_range_copy(
-				Input const& input, Result const& result,
-				typename sprout::container_traits<Input>::value_type const& low,
-				typename sprout::container_traits<Input>::value_type const& high,
+				InputRange const& rng, Result const& result,
+				typename sprout::container_traits<InputRange>::value_type const& low,
+				typename sprout::container_traits<InputRange>::value_type const& high,
 				Compare comp
 				)
 			{
-				return sprout::fixed::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high, comp);
+				return sprout::fixed::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high, comp);
 			}
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 			clamp_range_copy(
-				Input const& input, Result const& result,
-				typename sprout::container_traits<Input>::value_type const& low,
-				typename sprout::container_traits<Input>::value_type const& high
+				InputRange const& rng, Result const& result,
+				typename sprout::container_traits<InputRange>::value_type const& low,
+				typename sprout::container_traits<InputRange>::value_type const& high
 				)
 			{
-				return sprout::fixed::clamp_range_copy(sprout::begin(input), sprout::end(input), result, low, high);
+				return sprout::fixed::clamp_range_copy(sprout::begin(rng), sprout::end(rng), result, low, high);
 			}
 
-			template<typename Result, typename Input, typename Compare>
+			template<typename Result, typename InputRange, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 			clamp_range_copy(
-				Input const& input,
-				typename sprout::container_traits<Input>::value_type const& low,
-				typename sprout::container_traits<Input>::value_type const& high,
+				InputRange const& rng,
+				typename sprout::container_traits<InputRange>::value_type const& low,
+				typename sprout::container_traits<InputRange>::value_type const& high,
 				Compare comp
 				)
 			{
-				return sprout::fixed::clamp_range_copy<Result>(sprout::begin(input), sprout::end(input), low, high, comp);
+				return sprout::fixed::clamp_range_copy<Result>(sprout::begin(rng), sprout::end(rng), low, high, comp);
 			}
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 			clamp_range_copy(
-				Input const& input,
-				typename sprout::container_traits<Input>::value_type const& low,
-				typename sprout::container_traits<Input>::value_type const& high
+				InputRange const& rng,
+				typename sprout::container_traits<InputRange>::value_type const& low,
+				typename sprout::container_traits<InputRange>::value_type const& high
 				)
 			{
-				return sprout::fixed::clamp_range_copy<Result>(sprout::begin(input), sprout::end(input), low, high);
+				return sprout::fixed::clamp_range_copy<Result>(sprout::begin(rng), sprout::end(rng), low, high);
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/copy.hpp b/sprout/range/algorithm/fixed/copy.hpp
index 8e6de8c8..58063b52 100644
--- a/sprout/range/algorithm/fixed/copy.hpp
+++ b/sprout/range/algorithm/fixed/copy.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// copy
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			copy(Input const& input, Result const& result) {
-				return sprout::fixed::copy(sprout::begin(input), sprout::end(input), result);
+			copy(InputRange const& rng, Result const& result) {
+				return sprout::fixed::copy(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			copy(Input const& input) {
-				return sprout::fixed::copy<Result>(sprout::begin(input), sprout::end(input));
+			copy(InputRange const& rng) {
+				return sprout::fixed::copy<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/copy_backward.hpp b/sprout/range/algorithm/fixed/copy_backward.hpp
index 22269f53..cf114d08 100644
--- a/sprout/range/algorithm/fixed/copy_backward.hpp
+++ b/sprout/range/algorithm/fixed/copy_backward.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// copy_backward
 			//
-			template<typename Input, typename Result>
+			template<typename BidirectionalRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			copy_backward(Input const& input, Result const& result) {
-				return sprout::fixed::copy_backward(sprout::begin(input), sprout::end(input), result);
+			copy_backward(BidirectionalRange const& rng, Result const& result) {
+				return sprout::fixed::copy_backward(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename BidirectionalRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			copy_backward(Input const& input) {
-				return sprout::fixed::copy_backward<Result>(sprout::begin(input), sprout::end(input));
+			copy_backward(BidirectionalRange const& rng) {
+				return sprout::fixed::copy_backward<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/copy_if.hpp b/sprout/range/algorithm/fixed/copy_if.hpp
index af04e113..a661e2cc 100644
--- a/sprout/range/algorithm/fixed/copy_if.hpp
+++ b/sprout/range/algorithm/fixed/copy_if.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// copy_if
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename InputRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			copy_if(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fixed::copy_if(sprout::begin(input), sprout::end(input), result);
+			copy_if(InputRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fixed::copy_if(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input, typename Predicate>
+			template<typename Result, typename InputRange, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			copy_if(Input const& input, Predicate pred) {
-				return sprout::fixed::copy_if<Result>(sprout::begin(input), sprout::end(input));
+			copy_if(InputRange const& rng, Predicate pred) {
+				return sprout::fixed::copy_if<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/copy_until.hpp b/sprout/range/algorithm/fixed/copy_until.hpp
index 0ef743a6..9600768d 100644
--- a/sprout/range/algorithm/fixed/copy_until.hpp
+++ b/sprout/range/algorithm/fixed/copy_until.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// copy_until
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename InputRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			copy_until(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fixed::copy_until(sprout::begin(input), sprout::end(input), result);
+			copy_until(InputRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fixed::copy_until(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input, typename Predicate>
+			template<typename Result, typename InputRange, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			copy_until(Input const& input, Predicate pred) {
-				return sprout::fixed::copy_until<Result>(sprout::begin(input), sprout::end(input));
+			copy_until(InputRange const& rng, Predicate pred) {
+				return sprout::fixed::copy_until<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/copy_while.hpp b/sprout/range/algorithm/fixed/copy_while.hpp
index 648e0e25..ee583e2d 100644
--- a/sprout/range/algorithm/fixed/copy_while.hpp
+++ b/sprout/range/algorithm/fixed/copy_while.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// copy_while
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename InputRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			copy_while(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fixed::copy_while(sprout::begin(input), sprout::end(input), result);
+			copy_while(InputRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fixed::copy_while(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input, typename Predicate>
+			template<typename Result, typename InputRange, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			copy_while(Input const& input, Predicate pred) {
-				return sprout::fixed::copy_while<Result>(sprout::begin(input), sprout::end(input));
+			copy_while(InputRange const& rng, Predicate pred) {
+				return sprout::fixed::copy_while<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/merge.hpp b/sprout/range/algorithm/fixed/merge.hpp
index 71324f6c..154ffdb1 100644
--- a/sprout/range/algorithm/fixed/merge.hpp
+++ b/sprout/range/algorithm/fixed/merge.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// merge
 			//
-			template<typename Input1, typename Input2, typename Result, typename Compare>
+			template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			merge(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
-				return sprout::fixed::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
+			merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
+				return sprout::fixed::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
 			}
-			template<typename Input1, typename Input2, typename Result>
+			template<typename InputRange1, typename InputRange2, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			merge(Input1 const& input1, Input2 const& input2, Result const& result) {
-				return sprout::fixed::merge(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
+			merge(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
+				return sprout::fixed::merge(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
 			}
 
-			template<typename Result, typename Input1, typename Input2, typename Compare>
+			template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			merge(Input1 const& input1, Input2 const& input2, Compare comp) {
-				return sprout::fixed::merge<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
+			merge(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
+				return sprout::fixed::merge<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
 			}
-			template<typename Result, typename Input1, typename Input2>
+			template<typename Result, typename InputRange1, typename InputRange2>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			merge(Input1 const& input1, Input2 const& input2) {
-				return sprout::fixed::merge<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
+			merge(InputRange1 const& rng1, InputRange2 const& rng2) {
+				return sprout::fixed::merge<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/partition_copy.hpp b/sprout/range/algorithm/fixed/partition_copy.hpp
index 32dcda75..f7d5fb98 100644
--- a/sprout/range/algorithm/fixed/partition_copy.hpp
+++ b/sprout/range/algorithm/fixed/partition_copy.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// partition_copy
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename InputRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			partition_copy(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fixed::partition_copy(sprout::begin(input), sprout::end(input), result, pred);
+			partition_copy(InputRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fixed::partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
 			}
 
-			template<typename Result, typename Input, typename Predicate>
+			template<typename Result, typename InputRange, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			partition_copy(Input const& input, Predicate pred) {
-				return sprout::fixed::partition_copy<Result>(sprout::begin(input), sprout::end(input), pred);
+			partition_copy(InputRange const& rng, Predicate pred) {
+				return sprout::fixed::partition_copy<Result>(sprout::begin(rng), sprout::end(rng), pred);
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/remove_copy.hpp b/sprout/range/algorithm/fixed/remove_copy.hpp
index c8a526e2..60eea621 100644
--- a/sprout/range/algorithm/fixed/remove_copy.hpp
+++ b/sprout/range/algorithm/fixed/remove_copy.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// remove_copy
 			//
-			template<typename Input, typename Result, typename T>
+			template<typename InputRange, typename Result, typename T>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			remove_copy(Input const& input, Result const& result, T const& value) {
-				return sprout::fixed::remove_copy(sprout::begin(input), sprout::end(input), result, value);
+			remove_copy(InputRange const& rng, Result const& result, T const& value) {
+				return sprout::fixed::remove_copy(sprout::begin(rng), sprout::end(rng), result, value);
 			}
 
-			template<typename Result, typename Input, typename T>
+			template<typename Result, typename InputRange, typename T>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			remove_copy(Input const& input, Result const& result, T const& value) {
-				return sprout::fixed::remove_copy<Result>(sprout::begin(input), sprout::end(input), value);
+			remove_copy(InputRange const& rng, Result const& result, T const& value) {
+				return sprout::fixed::remove_copy<Result>(sprout::begin(rng), sprout::end(rng), value);
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/remove_copy_if.hpp b/sprout/range/algorithm/fixed/remove_copy_if.hpp
index babaf8d8..af965973 100644
--- a/sprout/range/algorithm/fixed/remove_copy_if.hpp
+++ b/sprout/range/algorithm/fixed/remove_copy_if.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// remove_copy_if
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename InputRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			remove_copy_if(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fixed::remove_copy_if(sprout::begin(input), sprout::end(input), result, pred);
+			remove_copy_if(InputRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fixed::remove_copy_if(sprout::begin(rng), sprout::end(rng), result, pred);
 			}
 
-			template<typename Result, typename Input, typename Predicate>
+			template<typename Result, typename InputRange, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			remove_copy_if(Input const& input, Predicate pred) {
-				return sprout::fixed::remove_copy_if<Result>(sprout::begin(input), sprout::end(input), pred);
+			remove_copy_if(InputRange const& rng, Predicate pred) {
+				return sprout::fixed::remove_copy_if<Result>(sprout::begin(rng), sprout::end(rng), pred);
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/replace_copy.hpp b/sprout/range/algorithm/fixed/replace_copy.hpp
index 7019ae4d..c4483416 100644
--- a/sprout/range/algorithm/fixed/replace_copy.hpp
+++ b/sprout/range/algorithm/fixed/replace_copy.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// replace_copy
 			//
-			template<typename Input, typename Result, typename T>
+			template<typename InputRange, typename Result, typename T>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			replace_copy(Input const& input, Result const& result, T const& old_value, T const& new_value) {
-				return sprout::fixed::replace_copy(sprout::begin(input), sprout::end(input), result, old_value, new_value);
+			replace_copy(InputRange const& rng, Result const& result, T const& old_value, T const& new_value) {
+				return sprout::fixed::replace_copy(sprout::begin(rng), sprout::end(rng), result, old_value, new_value);
 			}
 
-			template<typename Result, typename Input, typename T>
+			template<typename Result, typename InputRange, typename T>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			replace_copy(Input const& input, T const& old_value, T const& new_value) {
-				return sprout::fixed::replace_copy<Result>(sprout::begin(input), sprout::end(input), old_value, new_value);
+			replace_copy(InputRange const& rng, T const& old_value, T const& new_value) {
+				return sprout::fixed::replace_copy<Result>(sprout::begin(rng), sprout::end(rng), old_value, new_value);
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/replace_copy_if.hpp b/sprout/range/algorithm/fixed/replace_copy_if.hpp
index 647d12e8..962e2337 100644
--- a/sprout/range/algorithm/fixed/replace_copy_if.hpp
+++ b/sprout/range/algorithm/fixed/replace_copy_if.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// replace_copy_if
 			//
-			template<typename Input, typename Result, typename T, typename Predicate>
+			template<typename InputRange, typename Result, typename T, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			replace_copy_if(Input const& input, Result const& result, Predicate pred, T const& new_value) {
-				return sprout::fixed::replace_copy_if(sprout::begin(input), sprout::end(input), result, pred, new_value);
+			replace_copy_if(InputRange const& rng, Result const& result, Predicate pred, T const& new_value) {
+				return sprout::fixed::replace_copy_if(sprout::begin(rng), sprout::end(rng), result, pred, new_value);
 			}
 
-			template<typename Result, typename Input, typename T, typename Predicate>
+			template<typename Result, typename InputRange, typename T, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			replace_copy_if(Input const& input, Predicate pred, T const& new_value) {
-				return sprout::fixed::replace_copy_if<Result>(sprout::begin(input), sprout::end(input), pred, new_value);
+			replace_copy_if(InputRange const& rng, Predicate pred, T const& new_value) {
+				return sprout::fixed::replace_copy_if<Result>(sprout::begin(rng), sprout::end(rng), pred, new_value);
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/reverse_copy.hpp b/sprout/range/algorithm/fixed/reverse_copy.hpp
index 3c1f0326..7d90cb90 100644
--- a/sprout/range/algorithm/fixed/reverse_copy.hpp
+++ b/sprout/range/algorithm/fixed/reverse_copy.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// reverse_copy
 			//
-			template<typename Input, typename Result>
+			template<typename BidirectionalRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			reverse_copy(Input const& input, Result const& result) {
-				return sprout::fixed::reverse_copy(sprout::begin(input), sprout::end(input), result);
+			reverse_copy(BidirectionalRange const& rng, Result const& result) {
+				return sprout::fixed::reverse_copy(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename BidirectionalRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			reverse_copy(Input const& input) {
-				return sprout::fixed::reverse_copy<Result>(sprout::begin(input), sprout::end(input));
+			reverse_copy(BidirectionalRange const& rng) {
+				return sprout::fixed::reverse_copy<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/rotate_copy.hpp b/sprout/range/algorithm/fixed/rotate_copy.hpp
index 3188c669..3fd386bb 100644
--- a/sprout/range/algorithm/fixed/rotate_copy.hpp
+++ b/sprout/range/algorithm/fixed/rotate_copy.hpp
@@ -13,23 +13,23 @@ namespace sprout {
 			//
 			// rotate_copy
 			//
-			template<typename Input, typename Result>
+			template<typename ForwardRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 			rotate_copy(
-				Input const& input, typename sprout::container_traits<Input>::const_iterator middle,
+				ForwardRange const& rng, typename sprout::container_traits<ForwardRange>::const_iterator middle,
 				Result const& result
 				)
 			{
-				return sprout::fixed::rotate_copy(sprout::begin(input), middle, sprout::end(input), result);
+				return sprout::fixed::rotate_copy(sprout::begin(rng), middle, sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename ForwardRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 			rotate_copy(
-				Input const& input, typename sprout::container_traits<Input>::const_iterator middle
+				ForwardRange const& rng, typename sprout::container_traits<ForwardRange>::const_iterator middle
 				)
 			{
-				return sprout::fixed::rotate_copy<Result>(sprout::begin(input), middle, sprout::end(input));
+				return sprout::fixed::rotate_copy<Result>(sprout::begin(rng), middle, sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/set_difference.hpp b/sprout/range/algorithm/fixed/set_difference.hpp
index 53d4784e..610073c6 100644
--- a/sprout/range/algorithm/fixed/set_difference.hpp
+++ b/sprout/range/algorithm/fixed/set_difference.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// set_difference
 			//
-			template<typename Input1, typename Input2, typename Result, typename Compare>
+			template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
-				return sprout::fixed::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
+			set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
+				return sprout::fixed::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
 			}
-			template<typename Input1, typename Input2, typename Result>
+			template<typename InputRange1, typename InputRange2, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
-				return sprout::fixed::set_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
+			set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
+				return sprout::fixed::set_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
 			}
 
-			template<typename Result, typename Input1, typename Input2, typename Compare>
+			template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_difference(Input1 const& input1, Input2 const& input2, Compare comp) {
-				return sprout::fixed::set_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
+			set_difference(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
+				return sprout::fixed::set_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
 			}
-			template<typename Result, typename Input1, typename Input2>
+			template<typename Result, typename InputRange1, typename InputRange2>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_difference(Input1 const& input1, Input2 const& input2) {
-				return sprout::fixed::set_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
+			set_difference(InputRange1 const& rng1, InputRange2 const& rng2) {
+				return sprout::fixed::set_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/set_intersection.hpp b/sprout/range/algorithm/fixed/set_intersection.hpp
index bb39974d..ad4a5f10 100644
--- a/sprout/range/algorithm/fixed/set_intersection.hpp
+++ b/sprout/range/algorithm/fixed/set_intersection.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// set_intersection
 			//
-			template<typename Input1, typename Input2, typename Result, typename Compare>
+			template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_intersection(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
-				return sprout::fixed::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
+			set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
+				return sprout::fixed::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
 			}
-			template<typename Input1, typename Input2, typename Result>
+			template<typename InputRange1, typename InputRange2, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_intersection(Input1 const& input1, Input2 const& input2, Result const& result) {
-				return sprout::fixed::set_intersection(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
+			set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
+				return sprout::fixed::set_intersection(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
 			}
 
-			template<typename Result, typename Input1, typename Input2, typename Compare>
+			template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_intersection(Input1 const& input1, Input2 const& input2, Compare comp) {
-				return sprout::fixed::set_intersection<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
+			set_intersection(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
+				return sprout::fixed::set_intersection<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
 			}
-			template<typename Result, typename Input1, typename Input2>
+			template<typename Result, typename InputRange1, typename InputRange2>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_intersection(Input1 const& input1, Input2 const& input2) {
-				return sprout::fixed::set_intersection<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
+			set_intersection(InputRange1 const& rng1, InputRange2 const& rng2) {
+				return sprout::fixed::set_intersection<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/set_symmetric_difference.hpp b/sprout/range/algorithm/fixed/set_symmetric_difference.hpp
index 0b0854c3..83cdb2a1 100644
--- a/sprout/range/algorithm/fixed/set_symmetric_difference.hpp
+++ b/sprout/range/algorithm/fixed/set_symmetric_difference.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// set_symmetric_difference
 			//
-			template<typename Input1, typename Input2, typename Result, typename Compare>
+			template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
-				return sprout::fixed::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
+			set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
+				return sprout::fixed::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
 			}
-			template<typename Input1, typename Input2, typename Result>
+			template<typename InputRange1, typename InputRange2, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_symmetric_difference(Input1 const& input1, Input2 const& input2, Result const& result) {
-				return sprout::fixed::set_symmetric_difference(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
+			set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
+				return sprout::fixed::set_symmetric_difference(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
 			}
 
-			template<typename Result, typename Input1, typename Input2, typename Compare>
+			template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_symmetric_difference(Input1 const& input1, Input2 const& input2, Compare comp) {
-				return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
+			set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
+				return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
 			}
-			template<typename Result, typename Input1, typename Input2>
+			template<typename Result, typename InputRange1, typename InputRange2>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_symmetric_difference(Input1 const& input1, Input2 const& input2) {
-				return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
+			set_symmetric_difference(InputRange1 const& rng1, InputRange2 const& rng2) {
+				return sprout::fixed::set_symmetric_difference<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/set_union.hpp b/sprout/range/algorithm/fixed/set_union.hpp
index 934ea49c..c1c1fb8f 100644
--- a/sprout/range/algorithm/fixed/set_union.hpp
+++ b/sprout/range/algorithm/fixed/set_union.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// set_union
 			//
-			template<typename Input1, typename Input2, typename Result, typename Compare>
+			template<typename InputRange1, typename InputRange2, typename Result, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_union(Input1 const& input1, Input2 const& input2, Result const& result, Compare comp) {
-				return sprout::fixed::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result, comp);
+			set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, Compare comp) {
+				return sprout::fixed::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result, comp);
 			}
-			template<typename Input1, typename Input2, typename Result>
+			template<typename InputRange1, typename InputRange2, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_union(Input1 const& input1, Input2 const& input2, Result const& result) {
-				return sprout::fixed::set_union(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), result);
+			set_union(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result) {
+				return sprout::fixed::set_union(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), result);
 			}
 
-			template<typename Result, typename Input1, typename Input2, typename Compare>
+			template<typename Result, typename InputRange1, typename InputRange2, typename Compare>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_union(Input1 const& input1, Input2 const& input2, Compare comp) {
-				return sprout::fixed::set_union<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2), comp);
+			set_union(InputRange1 const& rng1, InputRange2 const& rng2, Compare comp) {
+				return sprout::fixed::set_union<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2), comp);
 			}
-			template<typename Result, typename Input1, typename Input2>
+			template<typename Result, typename InputRange1, typename InputRange2>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			set_union(Input1 const& input1, Input2 const& input2) {
-				return sprout::fixed::set_union<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), sprout::end(input2));
+			set_union(InputRange1 const& rng1, InputRange2 const& rng2) {
+				return sprout::fixed::set_union<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), sprout::end(rng2));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/stable_partition_copy.hpp b/sprout/range/algorithm/fixed/stable_partition_copy.hpp
index 9810838a..53f9cdb0 100644
--- a/sprout/range/algorithm/fixed/stable_partition_copy.hpp
+++ b/sprout/range/algorithm/fixed/stable_partition_copy.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// stable_partition_copy
 			//
-			template<typename Input, typename Result, typename Predicate>
+			template<typename BidirectionalRange, typename Result, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			stable_partition_copy(Input const& input, Result const& result, Predicate pred) {
-				return sprout::fixed::stable_partition_copy(sprout::begin(input), sprout::end(input), result, pred);
+			stable_partition_copy(BidirectionalRange const& rng, Result const& result, Predicate pred) {
+				return sprout::fixed::stable_partition_copy(sprout::begin(rng), sprout::end(rng), result, pred);
 			}
 
-			template<typename Result, typename Input, typename Predicate>
+			template<typename Result, typename BidirectionalRange, typename Predicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			stable_partition_copy(Input const& input, Predicate pred) {
-				return sprout::fixed::stable_partition_copy<Result>(sprout::begin(input), sprout::end(input), pred);
+			stable_partition_copy(BidirectionalRange const& rng, Predicate pred) {
+				return sprout::fixed::stable_partition_copy<Result>(sprout::begin(rng), sprout::end(rng), pred);
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/swap_element_copy.hpp b/sprout/range/algorithm/fixed/swap_element_copy.hpp
index 93a01fd1..b089a07b 100644
--- a/sprout/range/algorithm/fixed/swap_element_copy.hpp
+++ b/sprout/range/algorithm/fixed/swap_element_copy.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// swap_element_copy
 			//
-			template<typename Input, typename Result>
+			template<typename ForwardRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 			swap_element_copy(
-				Input const& input, Result const& result,
-				typename sprout::container_traits<Input>::const_iterator pos1,
-				typename sprout::container_traits<Input>::const_iterator pos2
+				ForwardRange const& rng, Result const& result,
+				typename sprout::container_traits<ForwardRange>::const_iterator pos1,
+				typename sprout::container_traits<ForwardRange>::const_iterator pos2
 				)
 			{
-				return sprout::fixed::swap_element_copy(sprout::begin(input), sprout::end(input), result, pos1, pos2);
+				return sprout::fixed::swap_element_copy(sprout::begin(rng), sprout::end(rng), result, pos1, pos2);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename ForwardRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 			swap_element_copy(
-				Input const& input,
-				typename sprout::container_traits<Input>::const_iterator pos1,
-				typename sprout::container_traits<Input>::const_iterator pos2
+				ForwardRange const& rng,
+				typename sprout::container_traits<ForwardRange>::const_iterator pos1,
+				typename sprout::container_traits<ForwardRange>::const_iterator pos2
 				)
 			{
-				return sprout::fixed::swap_element_copy<Result>(sprout::begin(input), sprout::end(input), pos1, pos2);
+				return sprout::fixed::swap_element_copy<Result>(sprout::begin(rng), sprout::end(rng), pos1, pos2);
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/transform.hpp b/sprout/range/algorithm/fixed/transform.hpp
index 10833f0a..8b446bbb 100644
--- a/sprout/range/algorithm/fixed/transform.hpp
+++ b/sprout/range/algorithm/fixed/transform.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// transform
 			//
-			template<typename Input, typename Result, typename UnaryOperation>
+			template<typename InputRange, typename Result, typename UnaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			transform(Input const& input, Result const& result, UnaryOperation op) {
-				return sprout::fixed::transform(sprout::begin(input), sprout::end(input), result, op);
+			transform(InputRange const& rng, Result const& result, UnaryOperation op) {
+				return sprout::fixed::transform(sprout::begin(rng), sprout::end(rng), result, op);
 			}
-			template<typename Input1, typename Input2, typename Result, typename BinaryOperation>
+			template<typename InputRange1, typename InputRange2, typename Result, typename BinaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			transform(Input1 const& input1, Input2 const& input2, Result const& result, BinaryOperation op) {
-				return sprout::fixed::transform(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), result, op);
+			transform(InputRange1 const& rng1, InputRange2 const& rng2, Result const& result, BinaryOperation op) {
+				return sprout::fixed::transform(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), result, op);
 			}
 
-			template<typename Result, typename Input, typename UnaryOperation>
+			template<typename Result, typename InputRange, typename UnaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			transform(Input const& input, UnaryOperation op) {
-				return sprout::fixed::transform<Result>(sprout::begin(input), sprout::end(input), op);
+			transform(InputRange const& rng, UnaryOperation op) {
+				return sprout::fixed::transform<Result>(sprout::begin(rng), sprout::end(rng), op);
 			}
-			template<typename Result, typename Input1, typename Input2, typename BinaryOperation>
+			template<typename Result, typename InputRange1, typename InputRange2, typename BinaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			transform(Input1 const& input1, Input2 const& input2, BinaryOperation op) {
-				return sprout::fixed::transform<Result>(sprout::begin(input1), sprout::end(input1), sprout::begin(input2), op);
+			transform(InputRange1 const& rng1, InputRange2 const& rng2, BinaryOperation op) {
+				return sprout::fixed::transform<Result>(sprout::begin(rng1), sprout::end(rng1), sprout::begin(rng2), op);
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/algorithm/fixed/unique_copy.hpp b/sprout/range/algorithm/fixed/unique_copy.hpp
index 72854457..ceff80cd 100644
--- a/sprout/range/algorithm/fixed/unique_copy.hpp
+++ b/sprout/range/algorithm/fixed/unique_copy.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// unique_copy
 			//
-			template<typename Input, typename Result, typename BinaryPredicate>
+			template<typename InputRange, typename Result, typename BinaryPredicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			unique_copy(Input const& input, Result const& result, BinaryPredicate pred) {
-				return sprout::fixed::unique_copy(sprout::begin(input), sprout::end(input), result, pred);
+			unique_copy(InputRange const& rng, Result const& result, BinaryPredicate pred) {
+				return sprout::fixed::unique_copy(sprout::begin(rng), sprout::end(rng), result, pred);
 			}
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			unique_copy(Input const& input, Result const& result) {
-				return sprout::fixed::unique_copy(sprout::begin(input), sprout::end(input), result);
+			unique_copy(InputRange const& rng, Result const& result) {
+				return sprout::fixed::unique_copy(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input, typename BinaryPredicate>
+			template<typename Result, typename InputRange, typename BinaryPredicate>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			unique_copy(Input const& input, BinaryPredicate pred) {
-				return sprout::fixed::unique_copy<Result>(sprout::begin(input), sprout::end(input), pred);
+			unique_copy(InputRange const& rng, BinaryPredicate pred) {
+				return sprout::fixed::unique_copy<Result>(sprout::begin(rng), sprout::end(rng), pred);
 			}
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			unique_copy(Input const& input) {
-				return sprout::fixed::unique_copy<Result>(sprout::begin(input), sprout::end(input));
+			unique_copy(InputRange const& rng) {
+				return sprout::fixed::unique_copy<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/numeric/dft/dft_element.hpp b/sprout/range/numeric/dft/dft_element.hpp
index ca347e36..907884cb 100644
--- a/sprout/range/numeric/dft/dft_element.hpp
+++ b/sprout/range/numeric/dft/dft_element.hpp
@@ -11,9 +11,9 @@ namespace sprout {
 		//
 		// dft_element
 		//
-		template<typename Input>
-		inline SPROUT_CONSTEXPR typename sprout::container_traits<Input>::value_type
-		dft_element(Input const& input, typename sprout::container_traits<Input>::difference_type i) {
+		template<typename InputRange>
+		inline SPROUT_CONSTEXPR typename sprout::container_traits<InputRange>::value_type
+		dft_element(InputRange const& input, typename sprout::container_traits<InputRange>::difference_type i) {
 			return sprout::dft_element(sprout::begin(input), sprout::end(input), i);
 		}
 	}	// namespace range
diff --git a/sprout/range/numeric/dft/fit/amplitude_spectrum.hpp b/sprout/range/numeric/dft/fit/amplitude_spectrum.hpp
index b08e38f1..c0ba0b09 100644
--- a/sprout/range/numeric/dft/fit/amplitude_spectrum.hpp
+++ b/sprout/range/numeric/dft/fit/amplitude_spectrum.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// amplitude_spectrum
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			amplitude_spectrum(Input const& input, Result const& result) {
-				return sprout::fit::amplitude_spectrum(sprout::begin(input), sprout::end(input), result);
+			amplitude_spectrum(InputRange const& rng, Result const& result) {
+				return sprout::fit::amplitude_spectrum(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			amplitude_spectrum(Input const& input) {
-				return sprout::fit::amplitude_spectrum<Result>(sprout::begin(input), sprout::end(input));
+			amplitude_spectrum(InputRange const& rng) {
+				return sprout::fit::amplitude_spectrum<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/numeric/dft/fit/dft.hpp b/sprout/range/numeric/dft/fit/dft.hpp
index b1c5b5e6..a10e26f4 100644
--- a/sprout/range/numeric/dft/fit/dft.hpp
+++ b/sprout/range/numeric/dft/fit/dft.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// dft
 			//
-			template<typename Input, typename Result>
+			template<typename ForwardRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			dft(Input const& input, Result const& result) {
-				return sprout::fit::dft(sprout::begin(input), sprout::end(input), result);
+			dft(ForwardRange const& rng, Result const& result) {
+				return sprout::fit::dft(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename ForwardRange>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			dft(Input const& input) {
-				return sprout::fit::dft<Result>(sprout::begin(input), sprout::end(input));
+			dft(ForwardRange const& rng) {
+				return sprout::fit::dft<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/numeric/dft/fit/idft.hpp b/sprout/range/numeric/dft/fit/idft.hpp
index 32ad8431..655f33aa 100644
--- a/sprout/range/numeric/dft/fit/idft.hpp
+++ b/sprout/range/numeric/dft/fit/idft.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// idft
 			//
-			template<typename Input, typename Result>
+			template<typename ForwardRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			idft(Input const& input, Result const& result) {
-				return sprout::fit::idft(sprout::begin(input), sprout::end(input), result);
+			idft(ForwardRange const& rng, Result const& result) {
+				return sprout::fit::idft(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename ForwardRange>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			idft(Input const& input) {
-				return sprout::fit::idft<Result>(sprout::begin(input), sprout::end(input));
+			idft(ForwardRange const& rng) {
+				return sprout::fit::idft<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/numeric/dft/fit/phase_spectrum.hpp b/sprout/range/numeric/dft/fit/phase_spectrum.hpp
index d633b2af..69433031 100644
--- a/sprout/range/numeric/dft/fit/phase_spectrum.hpp
+++ b/sprout/range/numeric/dft/fit/phase_spectrum.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// phase_spectrum
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			phase_spectrum(Input const& input, Result const& result) {
-				return sprout::fit::phase_spectrum(sprout::begin(input), sprout::end(input), result);
+			phase_spectrum(InputRange const& rng, Result const& result) {
+				return sprout::fit::phase_spectrum(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			phase_spectrum(Input const& input) {
-				return sprout::fit::phase_spectrum<Result>(sprout::begin(input), sprout::end(input));
+			phase_spectrum(InputRange const& rng) {
+				return sprout::fit::phase_spectrum<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/numeric/dft/fit/spectrum.hpp b/sprout/range/numeric/dft/fit/spectrum.hpp
index f5c9e4f9..afaf0b0a 100644
--- a/sprout/range/numeric/dft/fit/spectrum.hpp
+++ b/sprout/range/numeric/dft/fit/spectrum.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// spectrum
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			spectrum(Input const& input, Result const& result) {
-				return sprout::fit::spectrum(sprout::begin(input), sprout::end(input), result);
+			spectrum(InputRange const& rng, Result const& result) {
+				return sprout::fit::spectrum(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			spectrum(Input const& input) {
-				return sprout::fit::spectrum<Result>(sprout::begin(input), sprout::end(input));
+			spectrum(InputRange const& rng) {
+				return sprout::fit::spectrum<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/numeric/dft/fixed/amplitude_spectrum.hpp b/sprout/range/numeric/dft/fixed/amplitude_spectrum.hpp
index 702e6c93..652bca0e 100644
--- a/sprout/range/numeric/dft/fixed/amplitude_spectrum.hpp
+++ b/sprout/range/numeric/dft/fixed/amplitude_spectrum.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// amplitude_spectrum
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			amplitude_spectrum(Input const& input, Result const& result) {
-				return sprout::fixed::amplitude_spectrum(sprout::begin(input), sprout::end(input), result);
+			amplitude_spectrum(InputRange const& rng, Result const& result) {
+				return sprout::fixed::amplitude_spectrum(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			amplitude_spectrum(Input const& input) {
-				return sprout::fixed::amplitude_spectrum<Result>(sprout::begin(input), sprout::end(input));
+			amplitude_spectrum(InputRange const& rng) {
+				return sprout::fixed::amplitude_spectrum<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/numeric/dft/fixed/dft.hpp b/sprout/range/numeric/dft/fixed/dft.hpp
index da78cee1..9e9323cb 100644
--- a/sprout/range/numeric/dft/fixed/dft.hpp
+++ b/sprout/range/numeric/dft/fixed/dft.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// dft
 			//
-			template<typename Input, typename Result>
+			template<typename ForwardRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			dft(Input const& input, Result const& result) {
-				return sprout::fixed::dft(sprout::begin(input), sprout::end(input), result);
+			dft(ForwardRange const& rng, Result const& result) {
+				return sprout::fixed::dft(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename ForwardRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			dft(Input const& input) {
-				return sprout::fixed::dft<Result>(sprout::begin(input), sprout::end(input));
+			dft(ForwardRange const& rng) {
+				return sprout::fixed::dft<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/numeric/dft/fixed/idft.hpp b/sprout/range/numeric/dft/fixed/idft.hpp
index 52fce1ec..cd45572f 100644
--- a/sprout/range/numeric/dft/fixed/idft.hpp
+++ b/sprout/range/numeric/dft/fixed/idft.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// idft
 			//
-			template<typename Input, typename Result>
+			template<typename ForwardRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			idft(Input const& input, Result const& result) {
-				return sprout::fixed::idft(sprout::begin(input), sprout::end(input), result);
+			idft(ForwardRange const& rng, Result const& result) {
+				return sprout::fixed::idft(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename ForwardRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			idft(Input const& input) {
-				return sprout::fixed::idft<Result>(sprout::begin(input), sprout::end(input));
+			idft(ForwardRange const& rng) {
+				return sprout::fixed::idft<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/numeric/dft/fixed/phase_spectrum.hpp b/sprout/range/numeric/dft/fixed/phase_spectrum.hpp
index 28556e2e..b949aae4 100644
--- a/sprout/range/numeric/dft/fixed/phase_spectrum.hpp
+++ b/sprout/range/numeric/dft/fixed/phase_spectrum.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// phase_spectrum
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			phase_spectrum(Input const& input, Result const& result) {
-				return sprout::fixed::phase_spectrum(sprout::begin(input), sprout::end(input), result);
+			phase_spectrum(InputRange const& rng, Result const& result) {
+				return sprout::fixed::phase_spectrum(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			phase_spectrum(Input const& input) {
-				return sprout::fixed::phase_spectrum<Result>(sprout::begin(input), sprout::end(input));
+			phase_spectrum(InputRange const& rng) {
+				return sprout::fixed::phase_spectrum<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/numeric/dft/fixed/spectrum.hpp b/sprout/range/numeric/dft/fixed/spectrum.hpp
index df1db2d3..2677441f 100644
--- a/sprout/range/numeric/dft/fixed/spectrum.hpp
+++ b/sprout/range/numeric/dft/fixed/spectrum.hpp
@@ -13,16 +13,16 @@ namespace sprout {
 			//
 			// spectrum
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			spectrum(Input const& input, Result const& result) {
-				return sprout::fixed::spectrum(sprout::begin(input), sprout::end(input), result);
+			spectrum(InputRange const& rng, Result const& result) {
+				return sprout::fixed::spectrum(sprout::begin(rng), sprout::end(rng), result);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			spectrum(Input const& input) {
-				return sprout::fixed::spectrum<Result>(sprout::begin(input), sprout::end(input));
+			spectrum(InputRange const& rng) {
+				return sprout::fixed::spectrum<Result>(sprout::begin(rng), sprout::end(rng));
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/numeric/dft/idft_element.hpp b/sprout/range/numeric/dft/idft_element.hpp
index fb6c2f18..c6911c3c 100644
--- a/sprout/range/numeric/dft/idft_element.hpp
+++ b/sprout/range/numeric/dft/idft_element.hpp
@@ -11,9 +11,9 @@ namespace sprout {
 		//
 		// idft_element
 		//
-		template<typename Input>
-		inline SPROUT_CONSTEXPR typename sprout::container_traits<Input>::value_type
-		idft_element(Input const& input, typename sprout::container_traits<Input>::difference_type i) {
+		template<typename InputRange>
+		inline SPROUT_CONSTEXPR typename sprout::container_traits<InputRange>::value_type
+		idft_element(InputRange const& input, typename sprout::container_traits<InputRange>::difference_type i) {
 			return sprout::idft_element(sprout::begin(input), sprout::end(input), i);
 		}
 	}	// namespace range
diff --git a/sprout/range/numeric/fit/adjacent_difference.hpp b/sprout/range/numeric/fit/adjacent_difference.hpp
index 6715c9a4..af255403 100644
--- a/sprout/range/numeric/fit/adjacent_difference.hpp
+++ b/sprout/range/numeric/fit/adjacent_difference.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// adjacent_difference
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			adjacent_difference(Input const& input, Result const& result) {
-				return sprout::fit::adjacent_difference(sprout::begin(input), sprout::end(input), result);
+			adjacent_difference(InputRange const& rng, Result const& result) {
+				return sprout::fit::adjacent_difference(sprout::begin(rng), sprout::end(rng), result);
 			}
-			template<typename Input, typename Result, typename BinaryOperation>
+			template<typename InputRange, typename Result, typename BinaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			adjacent_difference(Input const& input, Result const& result, BinaryOperation binary_op) {
-				return sprout::fit::adjacent_difference(sprout::begin(input), sprout::end(input), result, binary_op);
+			adjacent_difference(InputRange const& rng, Result const& result, BinaryOperation binary_op) {
+				return sprout::fit::adjacent_difference(sprout::begin(rng), sprout::end(rng), result, binary_op);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			adjacent_difference(Input const& input) {
-				return sprout::fit::adjacent_difference<Result>(sprout::begin(input), sprout::end(input));
+			adjacent_difference(InputRange const& rng) {
+				return sprout::fit::adjacent_difference<Result>(sprout::begin(rng), sprout::end(rng));
 			}
-			template<typename Result, typename Input, typename BinaryOperation>
+			template<typename Result, typename InputRange, typename BinaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			adjacent_difference(Input const& input, BinaryOperation binary_op) {
-				return sprout::fit::adjacent_difference<Result>(sprout::begin(input), sprout::end(input), binary_op);
+			adjacent_difference(InputRange const& rng, BinaryOperation binary_op) {
+				return sprout::fit::adjacent_difference<Result>(sprout::begin(rng), sprout::end(rng), binary_op);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/numeric/fit/partial_sum.hpp b/sprout/range/numeric/fit/partial_sum.hpp
index 8b2778dd..ccad87d1 100644
--- a/sprout/range/numeric/fit/partial_sum.hpp
+++ b/sprout/range/numeric/fit/partial_sum.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// partial_sum
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			partial_sum(Input const& input, Result const& result) {
-				return sprout::fit::partial_sum(sprout::begin(input), sprout::end(input), result);
+			partial_sum(InputRange const& rng, Result const& result) {
+				return sprout::fit::partial_sum(sprout::begin(rng), sprout::end(rng), result);
 			}
-			template<typename Input, typename Result, typename BinaryOperation>
+			template<typename InputRange, typename Result, typename BinaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			partial_sum(Input const& input, Result const& result, BinaryOperation binary_op) {
-				return sprout::fit::partial_sum(sprout::begin(input), sprout::end(input), result, binary_op);
+			partial_sum(InputRange const& rng, Result const& result, BinaryOperation binary_op) {
+				return sprout::fit::partial_sum(sprout::begin(rng), sprout::end(rng), result, binary_op);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			partial_sum(Input const& input) {
-				return sprout::fit::partial_sum<Result>(sprout::begin(input), sprout::end(input));
+			partial_sum(InputRange const& rng) {
+				return sprout::fit::partial_sum<Result>(sprout::begin(rng), sprout::end(rng));
 			}
-			template<typename Result, typename Input, typename BinaryOperation>
+			template<typename Result, typename InputRange, typename BinaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fit::result_of::algorithm<Result>::type
-			partial_sum(Input const& input, BinaryOperation binary_op) {
-				return sprout::fit::partial_sum<Result>(sprout::begin(input), sprout::end(input), binary_op);
+			partial_sum(InputRange const& rng, BinaryOperation binary_op) {
+				return sprout::fit::partial_sum<Result>(sprout::begin(rng), sprout::end(rng), binary_op);
 			}
 		}	// namespace fit
 	}	// namespace range
diff --git a/sprout/range/numeric/fixed/adjacent_difference.hpp b/sprout/range/numeric/fixed/adjacent_difference.hpp
index 7d7d6508..4690b513 100644
--- a/sprout/range/numeric/fixed/adjacent_difference.hpp
+++ b/sprout/range/numeric/fixed/adjacent_difference.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// adjacent_difference
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			adjacent_difference(Input const& input, Result const& result) {
-				return sprout::fixed::adjacent_difference(sprout::begin(input), sprout::end(input), result);
+			adjacent_difference(InputRange const& rng, Result const& result) {
+				return sprout::fixed::adjacent_difference(sprout::begin(rng), sprout::end(rng), result);
 			}
-			template<typename Input, typename Result, typename BinaryOperation>
+			template<typename InputRange, typename Result, typename BinaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			adjacent_difference(Input const& input, Result const& result, BinaryOperation binary_op) {
-				return sprout::fixed::adjacent_difference(sprout::begin(input), sprout::end(input), result, binary_op);
+			adjacent_difference(InputRange const& rng, Result const& result, BinaryOperation binary_op) {
+				return sprout::fixed::adjacent_difference(sprout::begin(rng), sprout::end(rng), result, binary_op);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			adjacent_difference(Input const& input) {
-				return sprout::fixed::adjacent_difference<Result>(sprout::begin(input), sprout::end(input));
+			adjacent_difference(InputRange const& rng) {
+				return sprout::fixed::adjacent_difference<Result>(sprout::begin(rng), sprout::end(rng));
 			}
-			template<typename Result, typename Input, typename BinaryOperation>
+			template<typename Result, typename InputRange, typename BinaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			adjacent_difference(Input const& input, BinaryOperation binary_op) {
-				return sprout::fixed::adjacent_difference<Result>(sprout::begin(input), sprout::end(input), binary_op);
+			adjacent_difference(InputRange const& rng, BinaryOperation binary_op) {
+				return sprout::fixed::adjacent_difference<Result>(sprout::begin(rng), sprout::end(rng), binary_op);
 			}
 		}	// namespace fixed
 
diff --git a/sprout/range/numeric/fixed/partial_sum.hpp b/sprout/range/numeric/fixed/partial_sum.hpp
index 41d46685..a3a7980b 100644
--- a/sprout/range/numeric/fixed/partial_sum.hpp
+++ b/sprout/range/numeric/fixed/partial_sum.hpp
@@ -13,26 +13,26 @@ namespace sprout {
 			//
 			// partial_sum
 			//
-			template<typename Input, typename Result>
+			template<typename InputRange, typename Result>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			partial_sum(Input const& input, Result const& result) {
-				return sprout::fixed::partial_sum(sprout::begin(input), sprout::end(input), result);
+			partial_sum(InputRange const& rng, Result const& result) {
+				return sprout::fixed::partial_sum(sprout::begin(rng), sprout::end(rng), result);
 			}
-			template<typename Input, typename Result, typename BinaryOperation>
+			template<typename InputRange, typename Result, typename BinaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			partial_sum(Input const& input, Result const& result, BinaryOperation binary_op) {
-				return sprout::fixed::partial_sum(sprout::begin(input), sprout::end(input), result, binary_op);
+			partial_sum(InputRange const& rng, Result const& result, BinaryOperation binary_op) {
+				return sprout::fixed::partial_sum(sprout::begin(rng), sprout::end(rng), result, binary_op);
 			}
 
-			template<typename Result, typename Input>
+			template<typename Result, typename InputRange>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			partial_sum(Input const& input) {
-				return sprout::fixed::partial_sum<Result>(sprout::begin(input), sprout::end(input));
+			partial_sum(InputRange const& rng) {
+				return sprout::fixed::partial_sum<Result>(sprout::begin(rng), sprout::end(rng));
 			}
-			template<typename Result, typename Input, typename BinaryOperation>
+			template<typename Result, typename InputRange, typename BinaryOperation>
 			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
-			partial_sum(Input const& input, BinaryOperation binary_op) {
-				return sprout::fixed::partial_sum<Result>(sprout::begin(input), sprout::end(input), binary_op);
+			partial_sum(InputRange const& rng, BinaryOperation binary_op) {
+				return sprout::fixed::partial_sum<Result>(sprout::begin(rng), sprout::end(rng), binary_op);
 			}
 		}	// namespace fixed
 
diff --git a/sprout/workaround/detail/uniform_int_distribution.hpp b/sprout/workaround/detail/uniform_int_distribution.hpp
new file mode 100644
index 00000000..36fba276
--- /dev/null
+++ b/sprout/workaround/detail/uniform_int_distribution.hpp
@@ -0,0 +1,17 @@
+#ifndef SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION_HPP
+#define SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION_HPP
+
+#include <sprout/config.hpp>
+#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
+#	include <sprout/random/uniform_smallint.hpp>
+#else
+#	include <sprout/random/uniform_int_distribution.hpp>
+#endif
+
+#ifdef SPROUT_WORKAROUND_NOT_TERMINATE_RECURSIVE_CONSTEXPR_FUNCTION_TEMPLATE
+#	define SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_smallint
+#else
+#	define SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION sprout::random::uniform_int_distribution
+#endif
+
+#endif	// #ifndef SPROUT_WORKAROUND_DETAIL_UNIFORM_INT_DISTRIBUTION_HPP