fix reverse_iterator

support STL container: some algorithms

sprout/algorithm/fixed/clamp_range_copy.hpp

@@ -8,8 +8,10 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
+#include <sprout/iterator/clamp_iterator.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/clamp.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 #include HDR_FUNCTIONAL_SSCRISK_CEL_OR_SPROUT
 
@@ -56,6 +58,7 @@ namespace sprout {
 					sprout::distance(first, last)
 					);
 			}
+
 			template<typename InputIterator, typename Result, typename Compare, typename... Args>
 			inline SPROUT_CONSTEXPR typename std::enable_if<
 				sprout::container_traits<Result>::static_size == sizeof...(Args),
@@ -107,6 +110,41 @@ namespace sprout {
 			{
 				return sprout::fixed::detail::clamp_range_copy_impl(first, last, result, low, high, comp, sprout::size(result));
 			}
+
+			template<typename InputIterator, typename Result, typename Compare>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			clamp_range_copy(
+				InputIterator first, InputIterator last, Result const& result,
+				typename std::iterator_traits<InputIterator>::value_type const& low,
+				typename std::iterator_traits<InputIterator>::value_type const& high,
+				Compare comp
+				)
+			{
+				typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
+				return sprout::fixed::detail::clamp_range_copy(first, last, result, low, high, comp, category());
+			}
+
+			template<typename InputIterator, typename Result, typename Compare>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			clamp_range_copy(
+				InputIterator first, InputIterator last, Result const& result,
+				typename std::iterator_traits<InputIterator>::value_type const& low,
+				typename std::iterator_traits<InputIterator>::value_type const& high,
+				Compare comp
+				)
+			{
+				return sprout::remake<Result>(
+					result, sprout::size(result),
+					sprout::make_clamp_iterator(first, low, high, comp),
+					sprout::make_clamp_iterator(last, low, high, comp)
+					);
+			}
 		}	// namespace detail
 		//
 		// clamp_range_copy
@@ -120,8 +158,7 @@ namespace sprout {
 			Compare comp
 			)
 		{
-			typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
-			return sprout::fixed::detail::clamp_range_copy(first, last, result, low, high, comp, category());
+			return sprout::fixed::detail::clamp_range_copy(first, last, result, low, high, comp);
 		}
 		template<typename InputIterator, typename Result>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
@@ -136,6 +173,28 @@ namespace sprout {
 				NS_SSCRISK_CEL_OR_SPROUT::less<typename std::iterator_traits<InputIterator>::value_type>()
 				);
 		}
+
+		template<typename Result, typename InputIterator, typename Compare>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		clamp_range_copy(
+			InputIterator first, InputIterator last,
+			typename std::iterator_traits<InputIterator>::value_type const& low,
+			typename std::iterator_traits<InputIterator>::value_type const& high,
+			Compare comp
+			)
+		{
+			return sprout::fixed::clamp_range_copy(first, last, sprout::pit<Result>(), low, high, comp);
+		}
+		template<typename Result, typename InputIterator>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		clamp_range_copy(
+			InputIterator first, InputIterator last,
+			typename std::iterator_traits<InputIterator>::value_type const& low,
+			typename std::iterator_traits<InputIterator>::value_type const& high
+			)
+		{
+			return sprout::fixed::clamp_range_copy(first, last, sprout::pit<Result>(), low, high);
+		}
 	}	// namespace fixed
 
 	using sprout::fixed::clamp_range_copy;

sprout/algorithm/fixed/copy.hpp

@@ -27,8 +27,7 @@ namespace sprout {
 				)
 			{
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
+					result, sprout::size(result),
 					(Indexes >= offset && sprout::math::less(Indexes, offset + size) && sprout::math::less(Indexes, offset + input_size)
 						? first[Indexes - offset]
 						: *sprout::next(sprout::internal_begin(result), Indexes)
@@ -107,8 +106,7 @@ namespace sprout {
 			>::type
 			copy(InputIterator first, InputIterator last, Result const& result) {
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
+					result, sprout::size(result),
 					first, last
 					);
 			}

sprout/algorithm/fixed/copy_backward.hpp

@@ -27,8 +27,7 @@ namespace sprout {
 				)
 			{
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
+					result, sprout::size(result),
 					(Indexes < offset && sprout::math::greater_equal(Indexes + size, offset) && sprout::math::greater_equal(Indexes + input_size, offset)
 						? last[Indexes - offset]
 						: *sprout::next(sprout::internal_begin(result), Indexes)
@@ -101,19 +100,6 @@ namespace sprout {
 				typedef typename std::iterator_traits<BidirectionalIterator>::iterator_category* category;
 				return sprout::fixed::detail::copy_backward(first, last, result, category());
 			}
-
-			template<typename BidirectionalIterator, typename Result>
-			inline SPROUT_CONSTEXPR typename std::enable_if<
-				!sprout::is_fixed_container<Result>::value,
-				typename sprout::fixed::result_of::algorithm<Result>::type
-			>::type
-			copy_backward(BidirectionalIterator first, BidirectionalIterator last, Result const& result) {
-				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
-					first, last
-					);
-			}
 		}	// namespace detail
 		//
 		// copy_backward

sprout/algorithm/fixed/copy_if.hpp

@@ -61,9 +61,9 @@ namespace sprout {
 			>::type
 			copy_if(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
-					sprout::make_filter_iterator(pred, first, last), sprout::make_filter_iterator(pred, last, last)
+					result, sprout::size(result),
+					sprout::make_filter_iterator(pred, first, last),
+					sprout::make_filter_iterator(pred, last, last)
 					);
 			}
 		}	// namespace detail

sprout/algorithm/fixed/copy_until.hpp

@@ -7,9 +7,12 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
+#include <sprout/iterator/while_iterator.hpp>
+#include <sprout/functional/not1.hpp>
 #include <sprout/algorithm/find_if.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/copy.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -24,6 +27,7 @@ namespace sprout {
 			{
 				return sprout::fixed::copy(first, sprout::find_if(first, last, pred), result);
 			}
+
 			template<typename InputIterator, typename Result, typename Predicate, typename... Args>
 			inline SPROUT_CONSTEXPR typename std::enable_if<
 				sprout::container_traits<Result>::static_size == sizeof...(Args),
@@ -62,6 +66,29 @@ namespace sprout {
 			{
 				return sprout::fixed::detail::copy_until_impl(first, last, result, pred, sprout::size(result));
 			}
+
+			template<typename InputIterator, typename Result, typename Predicate>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			copy_until(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
+				typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
+				return sprout::fixed::detail::copy_until(first, last, result, pred, category());
+			}
+
+			template<typename InputIterator, typename Result, typename Predicate>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			copy_until(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
+				return sprout::remake<Result>(
+					result, sprout::size(result),
+					sprout::make_while_iterator(sprout::not1(pred), first, last),
+					sprout::make_while_iterator(sprout::not1(pred), last, last)
+					);
+			}
 		}	// namespace detail
 		//
 		// copy_until
@@ -69,8 +96,13 @@ namespace sprout {
 		template<typename InputIterator, typename Result, typename Predicate>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		copy_until(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
-			typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
-			return sprout::fixed::detail::copy_until(first, last, result, pred, category());
+			return sprout::fixed::detail::copy_until(first, last, result, pred);
+		}
+
+		template<typename Result, typename InputIterator, typename Predicate>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		copy_until(InputIterator first, InputIterator last, Predicate pred) {
+			return sprout::fixed::copy_until(first, last, sprout::pit<Result>(), pred);
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/copy_while.hpp

@@ -7,9 +7,11 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
+#include <sprout/iterator/while_iterator.hpp>
 #include <sprout/algorithm/find_if_not.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/copy.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -24,6 +26,7 @@ namespace sprout {
 			{
 				return sprout::fixed::copy(first, sprout::find_if_not(first, last, pred), result);
 			}
+
 			template<typename InputIterator, typename Result, typename Predicate, typename... Args>
 			inline SPROUT_CONSTEXPR typename std::enable_if<
 				sprout::container_traits<Result>::static_size == sizeof...(Args),
@@ -62,6 +65,29 @@ namespace sprout {
 			{
 				return sprout::fixed::detail::copy_while_impl(first, last, result, pred, sprout::size(result));
 			}
+
+			template<typename InputIterator, typename Result, typename Predicate>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			copy_while(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
+				typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
+				return sprout::fixed::detail::copy_while(first, last, result, pred, category());
+			}
+
+			template<typename InputIterator, typename Result, typename Predicate>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			copy_while(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
+				return sprout::remake<Result>(
+					result, sprout::size(result),
+					sprout::make_while_iterator(pred, first, last),
+					sprout::make_while_iterator(pred, last, last)
+					);
+			}
 		}	// namespace detail
 		//
 		// copy_while
@@ -69,8 +95,13 @@ namespace sprout {
 		template<typename InputIterator, typename Result, typename Predicate>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		copy_while(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
-			typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
-			return sprout::fixed::detail::copy_while(first, last, result, pred, category());
+			return sprout::fixed::detail::copy_while(first, last, result, pred);
+		}
+
+		template< typename Result, typename InputIterator,typename Predicate>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		copy_while(InputIterator first, InputIterator last, Predicate pred) {
+			return sprout::fixed::copy_while(first, last, sprout::pit<Result>(), pred);
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/fill.hpp

@@ -8,6 +8,7 @@
 #include <sprout/iterator/operation.hpp>
 #include <sprout/iterator/value_iterator.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 
 namespace sprout {
 	namespace fixed {
@@ -22,8 +23,7 @@ namespace sprout {
 				)
 			{
 				return sprout::remake<Container>(
-					cont,
-					sprout::size(cont),
+					cont, sprout::size(cont),
 					(Indexes >= offset && Indexes < offset + size
 						? value
 						: *sprout::next(sprout::internal_begin(cont), Indexes)
@@ -52,9 +52,9 @@ namespace sprout {
 			>::type
 			fill(Container const& cont, T const& value) {
 				return sprout::remake<Container>(
-					cont,
-					sprout::size(cont),
-					sprout::value_iterator<T const&>(value), sprout::value_iterator<T const&>(value, 0)
+					cont, sprout::size(cont),
+					sprout::value_iterator<T const&>(value, sprout::size(cont)),
+					sprout::value_iterator<T const&>(value, 0)
 					);
 			}
 		}	// namespace detail
@@ -66,6 +66,12 @@ namespace sprout {
 		fill(Container const& cont, T const& value) {
 			return sprout::fixed::detail::fill(cont, value);
 		}
+
+		template<typename Container, typename T>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
+		fill(T const& value) {
+			return sprout::fixed::fill(sprout::pit<Container>(), value);
+		}
 	}	// namespace fixed
 
 	using sprout::fixed::fill;

sprout/algorithm/fixed/fill_n.hpp

@@ -5,8 +5,10 @@
 #include <sprout/index_tuple.hpp>
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
+#include <sprout/iterator/value_iterator.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/fill.hpp>
+#include <sprout/pit.hpp>
 
 namespace sprout {
 	namespace fixed {
@@ -32,9 +34,9 @@ namespace sprout {
 			>::type
 			fill_n(Container const& cont, Size n, T const& value) {
 				return sprout::remake<Container>(
-					cont,
-					n,
-					sprout::value_iterator<T const&>(value, n), sprout::value_iterator<T const&>(value, 0)
+					cont, n,
+					sprout::value_iterator<T const&>(value, n),
+					sprout::value_iterator<T const&>(value, 0)
 					);
 			}
 		}	// namespace detail
@@ -46,6 +48,12 @@ namespace sprout {
 		fill_n(Container const& cont, Size n, T const& value) {
 			return sprout::fixed::detail::fill_n(cont, n, value);
 		}
+
+		template<typename Container, typename Size, typename T>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
+		fill_n(Size n, T const& value) {
+			return sprout::fixed::fill_n(sprout::pit<Container>(), n, value);
+		}
 	}	// namespace fixed
 
 	using sprout::fixed::fill_n;

sprout/algorithm/fixed/generate.hpp

@@ -7,6 +7,7 @@
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/generator/functions.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -80,6 +81,12 @@ namespace sprout {
 		generate(Container const& cont, Generator const& gen) {
 			return sprout::fixed::detail::generate_impl(cont, gen, sprout::size(cont));
 		}
+
+		template<typename Container, typename Generator>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
+		generate(Generator const& gen) {
+			return sprout::fixed::generate(sprout::pit<Container>());
+		}
 	}	// namespace fixed
 
 	using sprout::fixed::generate;

sprout/algorithm/fixed/generate_n.hpp

@@ -5,6 +5,7 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/generate.hpp>
+#include <sprout/pit.hpp>
 
 namespace sprout {
 	namespace fixed {
@@ -16,6 +17,12 @@ namespace sprout {
 		generate_n(Container const& cont, Size n, Generator const& gen) {
 			return sprout::fixed::detail::generate_impl(cont, gen, n);
 		}
+
+		template<typename Container, typename Size, typename Generator>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
+		generate_n(Size n, Generator const& gen) {
+			return sprout::fixed::generate_n(sprout::pit<Container>(), n, gen);
+		}
 	}	// namespace fixed
 
 	using sprout::fixed::generate_n;

sprout/algorithm/fixed/recurrence.hpp

@@ -8,6 +8,7 @@
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -146,6 +147,12 @@ namespace sprout {
 		recurrence(Container const& cont, Generator const& gen, Inits const&... inits) {
 			return sprout::fixed::detail::recurrence_impl(cont, gen, sprout::size(cont), inits...);
 		}
+
+		template<typename Container, typename Generator, typename... Inits>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
+		recurrence(Generator const& gen, Inits const&... inits) {
+			return sprout::fixed::recurrence(sprout::pit<Container>(), gen, inits...);
+		}
 	}	// namespace fixed
 
 	using sprout::fixed::recurrence;

sprout/algorithm/fixed/recurrence_n.hpp

@@ -5,6 +5,7 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/recurrence.hpp>
+#include <sprout/pit.hpp>
 
 namespace sprout {
 	namespace fixed {
@@ -16,6 +17,12 @@ namespace sprout {
 		recurrence_n(Container const& cont, Size n, Generator const& gen, Inits const&... inits) {
 			return sprout::fixed::detail::recurrence_impl(cont, gen, n, inits...);
 		}
+
+		template<typename Container, typename Size, typename Generator, typename... Inits>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
+		recurrence_n(Size n, Generator const& gen, Inits const&... inits) {
+			return sprout::fixed::recurrence_n(sprout::pit<Container>(), n, gen, inits...);
+		}
 	}	// namespace fixed
 
 	using sprout::fixed::recurrence_n;

sprout/algorithm/fixed/remove_copy.hpp

@@ -6,7 +6,9 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
+#include <sprout/iterator/remove_iterator.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -45,6 +47,28 @@ namespace sprout {
 					: sprout::detail::container_complate(result, args...)
 					;
 			}
+
+			template<typename InputIterator, typename Result, typename T>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			remove_copy(InputIterator first, InputIterator last, Result const& result, T const& value) {
+				return sprout::fixed::detail::remove_copy_impl(first, last, result, value, sprout::size(result));
+			}
+
+			template<typename InputIterator, typename Result, typename T>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			remove_copy(InputIterator first, InputIterator last, Result const& result, T const& value) {
+				return sprout::remake<Result>(
+					result, sprout::size(result),
+					sprout::make_remove_iterator(value, first, last),
+					sprout::make_remove_iterator(value, last, last)
+					);
+			}
 		}	// namespace detail
 		//
 		// remove_copy
@@ -52,7 +76,13 @@ namespace sprout {
 		template<typename InputIterator, typename Result, typename T>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		remove_copy(InputIterator first, InputIterator last, Result const& result, T const& value) {
-			return sprout::fixed::detail::remove_copy_impl(first, last, result, value, sprout::size(result));
+			return sprout::fixed::detail::remove_copy(first, last, result, value);
+		}
+
+		template<typename Result, typename InputIterator, typename T>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		remove_copy(InputIterator first, InputIterator last, T const& value) {
+			return sprout::fixed::remove_copy(first, last, sprout::pit<Result>(), value);
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/remove_copy_if.hpp

@@ -6,7 +6,9 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
+#include <sprout/iterator/remove_if_iterator.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -45,6 +47,28 @@ namespace sprout {
 					: sprout::detail::container_complate(result, args...)
 					;
 			}
+
+			template<typename InputIterator, typename Result, typename Predicate>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			remove_copy_if(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
+				return sprout::fixed::detail::remove_copy_if_impl(first, last, result, pred, sprout::size(result));
+			}
+
+			template<typename InputIterator, typename Result, typename Predicate>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			remove_copy_if(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
+				return sprout::remake<Result>(
+					result, sprout::size(result),
+					sprout::make_remove_if_iterator(pred, first, last),
+					sprout::make_remove_if_iterator(pred, last, last)
+					);
+			}
 		}	// namespace detail
 		//
 		// remove_copy_if
@@ -52,7 +76,13 @@ namespace sprout {
 		template<typename InputIterator, typename Result, typename Predicate>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		remove_copy_if(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
-			return sprout::fixed::detail::remove_copy_if_impl(first, last, result, pred, sprout::size(result));
+			return sprout::fixed::detail::remove_copy_if(first, last, result, pred);
+		}
+
+		template<typename Result, typename InputIterator, typename Predicate>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		remove_copy_if(InputIterator first, InputIterator last, Predicate pred) {
+			return sprout::fixed::remove_copy_if(first, last, sprout::pit<Result>(), pred);
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/replace_copy.hpp

@@ -29,8 +29,7 @@ namespace sprout {
 				)
 			{
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
+					result, sprout::size(result),
 					(Indexes >= offset && Indexes < offset + size && Indexes < offset + input_size
 						? NS_SSCRISK_CEL_OR_SPROUT::equal_to<T>()(first[Indexes - offset], old_value) ? new_value : first[Indexes - offset]
 						: *sprout::next(sprout::internal_begin(result), Indexes)
@@ -117,8 +116,7 @@ namespace sprout {
 			>::type
 			replace_copy(InputIterator first, InputIterator last, Result const& result, T const& old_value, T const& new_value) {
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
+					result, sprout::size(result),
 					sprout::make_replace_iterator(first, old_value, new_value),
 					sprout::make_replace_iterator(last, old_value, new_value)
 					);

sprout/algorithm/fixed/replace_copy_if.hpp

@@ -28,8 +28,7 @@ namespace sprout {
 				)
 			{
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
+					result, sprout::size(result),
 					(Indexes >= offset && Indexes < offset + size && Indexes < offset + input_size
 						? pred(first[Indexes - offset]) ? new_value : first[Indexes - offset]
 						: *sprout::next(sprout::internal_begin(result), Indexes)
@@ -116,8 +115,7 @@ namespace sprout {
 			>::type
 			replace_copy_if(InputIterator first, InputIterator last, Result const& result, Predicate pred, T const& new_value) {
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
+					result, sprout::size(result),
 					sprout::make_replace_if_iterator(first, pred, new_value),
 					sprout::make_replace_if_iterator(last, pred, new_value)
 					);

sprout/algorithm/fixed/reverse_copy.hpp

@@ -8,7 +8,9 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
+#include <sprout/iterator/reverse_iterator.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -48,6 +50,7 @@ namespace sprout {
 					sprout::distance(first, last)
 					);
 			}
+
 			template<typename BidirectionalIterator, typename Result, typename... Args>
 			inline SPROUT_CONSTEXPR typename std::enable_if<
 				sprout::container_traits<Result>::static_size == sizeof...(Args),
@@ -86,6 +89,29 @@ namespace sprout {
 			{
 				return sprout::fixed::detail::reverse_copy_impl(first, last, result, sprout::size(result));
 			}
+
+			template<typename BidirectionalIterator, typename Result>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			reverse_copy(BidirectionalIterator first, BidirectionalIterator last, Result const& result) {
+				typedef typename std::iterator_traits<BidirectionalIterator>::iterator_category* category;
+				return sprout::fixed::detail::reverse_copy(first, last, result, category());
+			}
+
+			template<typename BidirectionalIterator, typename Result>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			reverse_copy(BidirectionalIterator first, BidirectionalIterator last, Result const& result) {
+				return sprout::remake<Result>(
+					result, sprout::size(result),
+					sprout::make_reverse_iterator(last),
+					sprout::make_reverse_iterator(first)
+					);
+			}
 		}	// namespace detail
 		//
 		// reverse_copy
@@ -93,8 +119,13 @@ namespace sprout {
 		template<typename BidirectionalIterator, typename Result>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		reverse_copy(BidirectionalIterator first, BidirectionalIterator last, Result const& result) {
-			typedef typename std::iterator_traits<BidirectionalIterator>::iterator_category* category;
-			return sprout::fixed::detail::reverse_copy(first, last, result, category());
+			return sprout::fixed::detail::reverse_copy(first, last, result);
+		}
+
+		template<typename Result, typename BidirectionalIterator>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		reverse_copy(BidirectionalIterator first, BidirectionalIterator last) {
+			return sprout::fixed::reverse_copy(first, last, sprout::pit<Result>());
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/rotate_copy.hpp

@@ -8,7 +8,9 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
+#include <sprout/iterator/joint_iterator.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -56,6 +58,7 @@ namespace sprout {
 					sprout::distance(first, last)
 					);
 			}
+
 			template<typename ForwardIterator, typename Result, typename... Args>
 			inline SPROUT_CONSTEXPR typename std::enable_if<
 				sprout::container_traits<Result>::static_size == sizeof...(Args),
@@ -129,6 +132,29 @@ namespace sprout {
 			{
 				return sprout::fixed::detail::rotate_copy_impl(first, middle, last, result, sprout::size(result));
 			}
+
+			template<typename ForwardIterator, typename Result>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, Result const& result) {
+				typedef typename std::iterator_traits<ForwardIterator>::iterator_category* category;
+				return sprout::fixed::detail::rotate_copy(first, middle, last, result, category());
+			}
+
+			template<typename ForwardIterator, typename Result>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, Result const& result) {
+				return sprout::remake<Result>(
+					result, sprout::size(result),
+					sprout::make_joint_iterator(middle, last, first, first),
+					sprout::make_joint_iterator(last, last, first, middle)
+					);
+			}
 		}	// namespace detail
 		//
 		// rotate_copy
@@ -136,8 +162,13 @@ namespace sprout {
 		template<typename ForwardIterator, typename Result>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, Result const& result) {
-			typedef typename std::iterator_traits<ForwardIterator>::iterator_category* category;
-			return sprout::fixed::detail::rotate_copy(first, middle, last, result, category());
+			return sprout::fixed::detail::rotate_copy(first, middle, last, result);
+		}
+
+		template<typename Result, typename ForwardIterator>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last) {
+			return sprout::fixed::rotate_copy(first, middle, last, sprout::pit<Result>());
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/swap_element_copy.hpp

@@ -58,6 +58,7 @@ namespace sprout {
 					sprout::distance(first, last)
 					);
 			}
+
 			template<typename ForwardIterator, typename Result, typename... Args>
 			inline SPROUT_CONSTEXPR typename std::enable_if<
 				sprout::container_traits<Result>::static_size == sizeof...(Args),

sprout/algorithm/fixed/transform.hpp

@@ -29,8 +29,7 @@ namespace sprout {
 				)
 			{
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
+					result, sprout::size(result),
 					(Indexes >= offset && Indexes < offset + size && Indexes < offset + input_size
 						? op(first[Indexes - offset])
 						: *sprout::next(sprout::internal_begin(result), Indexes)
@@ -114,9 +113,9 @@ namespace sprout {
 			>::type
 			transform(InputIterator first, InputIterator last, Result const& result, UnaryOperation op) {
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
-					sprout::make_transform_iterator(first, op), sprout::make_transform_iterator(last, op)
+					result, sprout::size(result),
+					sprout::make_transform_iterator(first, op),
+					sprout::make_transform_iterator(last, op)
 					);
 			}
 		}	// namespace detail
@@ -148,8 +147,7 @@ namespace sprout {
 				)
 			{
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
+					result, sprout::size(result),
 					(Indexes >= offset && Indexes < offset + size && Indexes < offset + input_size
 						? op(first1[Indexes - offset], first2[Indexes - offset])
 						: *sprout::next(sprout::internal_begin(result), Indexes)
@@ -232,8 +230,7 @@ namespace sprout {
 			>::type
 			transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, Result const& result, BinaryOperation op) {
 				return sprout::remake<Result>(
-					result,
-					sprout::size(result),
+					result, sprout::size(result),
 					sprout::make_transform_iterator(first1, first2, op),
 					sprout::make_transform_iterator(last1, first2, op)
 					);

sprout/algorithm/fixed/unfold.hpp

@@ -7,6 +7,7 @@
 #include <sprout/container/functions.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/generator/functions.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -79,6 +80,12 @@ namespace sprout {
 		unfold(Container const& cont, Generator const& gen, Init const& init) {
 			return sprout::fixed::detail::unfold_impl(cont, gen, init, sprout::size(cont));
 		}
+
+		template<typename Container, typename Generator, typename Init>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
+		unfold(Generator const& gen, Init const& init) {
+			return sprout::fixed::unfold(sprout::pit<Container>(), gen, init);
+		}
 	}	// namespace fixed
 
 	using sprout::fixed::unfold;

sprout/algorithm/fixed/unfold_n.hpp

@@ -5,6 +5,7 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/unfold.hpp>
+#include <sprout/pit.hpp>
 
 namespace sprout {
 	namespace fixed {
@@ -16,6 +17,12 @@ namespace sprout {
 		unfold_n(Container const& cont, Size n, Generator const& gen, Init const& init) {
 			return sprout::fixed::detail::unfold_impl(cont, gen, init, n);
 		}
+
+		template<typename Container, typename Size,typename Generator, typename Init>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
+		unfold_n(Size n, Generator const& gen, Init const& init) {
+			return sprout::fixed::unfold_n(sprout::pit<Container>(), n, gen, init);
+		}
 	}	// namespace fixed
 
 	using sprout::fixed::unfold_n;