fix support for STL container: some algorithms

sprout/algorithm/fixed/copy.hpp

@@ -9,6 +9,7 @@
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/math/comparison.hpp>
 #include <sprout/detail/container_complate.hpp>
 
@@ -94,18 +95,17 @@ namespace sprout {
 				sprout::is_fixed_container<Result>::value,
 				typename sprout::fixed::result_of::algorithm<Result>::type
 			>::type
-			copy(InputIterator first, InputIterator last, Result const& result)
-			{
+			copy(InputIterator first, InputIterator last, Result const& result) {
 				typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
 				return sprout::fixed::detail::copy(first, last, result, category());
 			}
+
 			template<typename InputIterator, 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(InputIterator first, InputIterator last, Result const& result)
-			{
+			copy(InputIterator first, InputIterator last, Result const& result) {
 				return sprout::remake<Result>(
 					result,
 					sprout::size(result),
@@ -121,6 +121,12 @@ namespace sprout {
 		copy(InputIterator first, InputIterator last, Result const& result) {
 			return sprout::fixed::detail::copy(first, last, result);
 		}
+
+		template<typename Result, typename InputIterator>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		copy(InputIterator first, InputIterator last) {
+			return sprout::fixed::copy(first, last, sprout::pit<Result>());
+		}
 	}	// namespace fixed
 
 	using sprout::fixed::copy;

sprout/algorithm/fixed/copy_backward.hpp

@@ -9,6 +9,7 @@
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/math/comparison.hpp>
 #include <sprout/detail/container_complate_backward.hpp>
 
@@ -86,12 +87,33 @@ namespace sprout {
 				)
 			{
 				return sprout::fixed::detail::copy_backward_impl(
-					first,
-					last,
-					result,
+					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
+			copy_backward(BidirectionalIterator first, BidirectionalIterator last, Result const& result) {
+				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
@@ -99,13 +121,13 @@ namespace sprout {
 		template<typename BidirectionalIterator, typename Result>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		copy_backward(BidirectionalIterator first, BidirectionalIterator last, Result const& result) {
-			typedef typename std::iterator_traits<BidirectionalIterator>::iterator_category* category;
-			return sprout::fixed::detail::copy_backward(
-				first,
-				last,
-				result,
-				category()
-				);
+			return sprout::fixed::detail::copy_backward(first, last, result);
+		}
+
+		template<typename Result, typename BidirectionalIterator>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		copy_backward(BidirectionalIterator first, BidirectionalIterator last) {
+			return sprout::fixed::copy_backward(first, last, sprout::pit<Result>());
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/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/filter_iterator.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -42,6 +44,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
+			copy_if(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
+				return sprout::fixed::detail::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
+			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)
+					);
+			}
 		}	// namespace detail
 		//
 		// copy_if
@@ -49,7 +73,13 @@ namespace sprout {
 		template<typename InputIterator, typename Result, typename Predicate>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		copy_if(InputIterator first, InputIterator last, Result const& result, Predicate pred) {
-			return sprout::fixed::detail::copy_if_impl(first, last, result, pred, sprout::size(result));
+			return sprout::fixed::detail::copy_if(first, last, result, pred);
+		}
+
+		template<typename Result, typename InputIterator, typename Predicate>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		copy_if(InputIterator first, InputIterator last, Predicate pred) {
+			return sprout::fixed::copy_if(first, last, sprout::pit<Result>(), pred);
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/copy_n.hpp

@@ -9,6 +9,7 @@
 #include <sprout/iterator/operation.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 #include <sprout/algorithm/fixed/copy.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/math/comparison.hpp>
 #include <sprout/detail/container_complate.hpp>
 
@@ -24,6 +25,7 @@ namespace sprout {
 			{
 				return sprout::fixed::copy(first, sprout::next(first, n), result);
 			}
+
 			template<typename InputIterator, typename Size, typename Result, typename... Args>
 			inline SPROUT_CONSTEXPR typename std::enable_if<
 				sprout::container_traits<Result>::static_size == sizeof...(Args),
@@ -61,6 +63,35 @@ namespace sprout {
 			{
 				return sprout::fixed::detail::copy_n_impl(first, n, result, sprout::size(result));
 			}
+
+			template<typename InputIterator, typename Size, 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_n(InputIterator first, Size n, Result const& result) {
+				typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
+				return sprout::fixed::detail::copy_n(first, n, result, category());
+			}
+
+			template<typename ForwardIterator, typename Size, typename Result>
+			inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+			copy_n_dyn(
+				ForwardIterator first, Size n, Result const& result,
+				std::forward_iterator_tag*
+				)
+			{
+				return sprout::fixed::copy(first, sprout::next(first, n), result);
+			}
+			template<typename InputIterator, typename Size, 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_n(InputIterator first, Size n, Result const& result) {
+				typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
+				return sprout::fixed::detail::copy_n_dyn(first, n, result, category());
+			}
 		}	// namespace detail
 		//
 		// copy_n
@@ -68,8 +99,13 @@ namespace sprout {
 		template<typename InputIterator, typename Size, typename Result>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		copy_n(InputIterator first, Size n, Result const& result) {
-			typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
-			return sprout::fixed::detail::copy_n(first, n, result, category());
+			return sprout::fixed::detail::copy_n(first, n, result);
+		}
+
+		template<typename Result, typename InputIterator, typename Size>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		copy_n(InputIterator first, Size n) {
+			return sprout::fixed::copy_n(first, n, sprout::pit<Result>());
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/fill.hpp

@@ -6,6 +6,7 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
+#include <sprout/iterator/value_iterator.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
 
 namespace sprout {
@@ -29,6 +30,33 @@ namespace sprout {
 						)...
 					);
 			}
+
+			template<typename Container, typename T>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Container>::value,
+				typename sprout::fixed::result_of::algorithm<Container>::type
+			>::type
+			fill(Container const& cont, T const& value) {
+				return sprout::fixed::detail::fill_impl(
+					cont, value,
+					sprout::index_range<0, sprout::container_traits<Container>::static_size>::make(),
+					sprout::internal_begin_offset(cont),
+					sprout::size(cont)
+					);
+			}
+
+			template<typename Container, typename T>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Container>::value,
+				typename sprout::fixed::result_of::algorithm<Container>::type
+			>::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)
+					);
+			}
 		}	// namespace detail
 		//
 		// fill
@@ -36,12 +64,7 @@ namespace sprout {
 		template<typename Container, typename T>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
 		fill(Container const& cont, T const& value) {
-			return sprout::fixed::detail::fill_impl(
-				cont, value,
-				sprout::index_range<0, sprout::container_traits<Container>::static_size>::make(),
-				sprout::internal_begin_offset(cont),
-				sprout::size(cont)
-				);
+			return sprout::fixed::detail::fill(cont, value);
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/fill_n.hpp

@@ -10,18 +10,41 @@
 
 namespace sprout {
 	namespace fixed {
+		namespace detail {
+			template<typename Container, typename Size, typename T>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Container>::value,
+				typename sprout::fixed::result_of::algorithm<Container>::type
+			>::type
+			fill_n(Container const& cont, Size n, T const& value) {
+				return sprout::fixed::detail::fill_impl(
+					cont, value,
+					sprout::index_range<0, sprout::container_traits<Container>::static_size>::make(),
+					sprout::internal_begin_offset(cont),
+					n
+					);
+			}
+
+			template<typename Container, typename Size, typename T>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Container>::value,
+				typename sprout::fixed::result_of::algorithm<Container>::type
+			>::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)
+					);
+			}
+		}	// namespace detail
 		//
 		// fill_n
 		//
 		template<typename Container, typename Size, typename T>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Container>::type
 		fill_n(Container const& cont, Size n, T const& value) {
-			return sprout::fixed::detail::fill_impl(
-				cont, value,
-				sprout::index_range<0, sprout::container_traits<Container>::static_size>::make(),
-				sprout::internal_begin_offset(cont),
-				n
-				);
+			return sprout::fixed::detail::fill_n(cont, n, value);
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/replace_copy.hpp

@@ -8,7 +8,9 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
+#include <sprout/iterator/replace_iterator.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 #include HDR_FUNCTIONAL_SSCRISK_CEL_OR_SPROUT
 
@@ -97,6 +99,30 @@ namespace sprout {
 			{
 				return sprout::fixed::detail::replace_copy_impl(first, last, result, old_value, new_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
+			replace_copy(InputIterator first, InputIterator last, Result const& result, T const& old_value, T const& new_value) {
+				typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
+				return sprout::fixed::detail::replace_copy(first, last, result, old_value, new_value, category());
+			}
+
+			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
+			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),
+					sprout::make_replace_iterator(first, old_value, new_value),
+					sprout::make_replace_iterator(last, old_value, new_value)
+					);
+			}
 		}	// namespace detail
 		//
 		// replace_copy
@@ -104,8 +130,13 @@ namespace sprout {
 		template<typename InputIterator, typename Result, typename T>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		replace_copy(InputIterator first, InputIterator last, Result const& result, T const& old_value, T const& new_value) {
-			typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
-			return sprout::fixed::detail::replace_copy(first, last, result, old_value, new_value, category());
+			return sprout::fixed::detail::replace_copy(first, last, result, old_value, new_value);
+		}
+
+		template<typename Result, typename InputIterator, typename T>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		replace_copy(InputIterator first, InputIterator last, T const& old_value, T const& new_value) {
+			return sprout::fixed::replace_copy(first, last, sprout::pit<Result>(), old_value, new_value);
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/replace_copy_if.hpp

@@ -8,7 +8,9 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
+#include <sprout/iterator/replace_if_iterator.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -96,6 +98,30 @@ namespace sprout {
 			{
 				return sprout::fixed::detail::replace_copy_if_impl(first, last, result, pred, new_value, sprout::size(result));
 			}
+
+			template<typename InputIterator, typename Result, typename T, typename Predicate>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			replace_copy_if(InputIterator first, InputIterator last, Result const& result, Predicate pred, T const& new_value) {
+				typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
+				return sprout::fixed::detail::replace_copy_if(first, last, result, pred, new_value, category());
+			}
+
+			template<typename InputIterator, typename Result, typename T, typename Predicate>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::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),
+					sprout::make_replace_if_iterator(first, pred, new_value),
+					sprout::make_replace_if_iterator(last, pred, new_value)
+					);
+			}
 		}	// namespace detail
 		//
 		// replace_copy_if
@@ -103,8 +129,13 @@ namespace sprout {
 		template<typename InputIterator, typename Result, typename T, typename Predicate>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		replace_copy_if(InputIterator first, InputIterator last, Result const& result, Predicate pred, T const& new_value) {
-			typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
-			return sprout::fixed::detail::replace_copy_if(first, last, result, pred, new_value, category());
+			return sprout::fixed::detail::replace_copy_if(first, last, result, pred, new_value);
+		}
+
+		template<typename Result, typename InputIterator, typename T, typename Predicate>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		replace_copy_if(InputIterator first, InputIterator last, Predicate pred, T const& new_value) {
+			return sprout::fixed::replace_copy_if(first, last, sprout::pit<Result>(), pred, new_value);
 		}
 	}	// namespace fixed
 

sprout/algorithm/fixed/transform.hpp

@@ -8,7 +8,10 @@
 #include <sprout/container/traits.hpp>
 #include <sprout/container/functions.hpp>
 #include <sprout/iterator/operation.hpp>
+#include <sprout/iterator/transform_iterator.hpp>
+#include <sprout/iterator/type_traits/common.hpp>
 #include <sprout/algorithm/fixed/result_of.hpp>
+#include <sprout/pit.hpp>
 #include <sprout/detail/container_complate.hpp>
 
 namespace sprout {
@@ -51,6 +54,7 @@ namespace sprout {
 					sprout::distance(first, last)
 					);
 			}
+
 			template<typename InputIterator, typename Result, typename UnaryOperation, typename... Args>
 			inline SPROUT_CONSTEXPR typename std::enable_if<
 				sprout::container_traits<Result>::static_size == sizeof...(Args),
@@ -92,6 +96,29 @@ namespace sprout {
 			{
 				return sprout::fixed::detail::transform_impl(first, last, result, op, sprout::size(result));
 			}
+
+			template<typename InputIterator, typename Result, typename UnaryOperation>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			transform(InputIterator first, InputIterator last, Result const& result, UnaryOperation op) {
+				typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
+				return sprout::fixed::detail::transform(first, last, result, op, category());
+			}
+
+			template<typename InputIterator, typename Result, typename UnaryOperation>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::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)
+					);
+			}
 		}	// namespace detail
 		//
 		// transform
@@ -99,8 +126,13 @@ namespace sprout {
 		template<typename InputIterator, typename Result, typename UnaryOperation>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		transform(InputIterator first, InputIterator last, Result const& result, UnaryOperation op) {
-			typedef typename std::iterator_traits<InputIterator>::iterator_category* category;
-			return sprout::fixed::detail::transform(first, last, result, op, category());
+			return sprout::fixed::detail::transform(first, last, result, op);
+		}
+
+		template<typename Result, typename InputIterator, typename UnaryOperation>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		transform(InputIterator first, InputIterator last, UnaryOperation op) {
+			return sprout::fixed::transform(first, last, sprout::pit<Result>(), op);
 		}
 
 		namespace detail {
@@ -182,6 +214,30 @@ namespace sprout {
 			{
 				return sprout::fixed::detail::transform_impl(first1, last1, first2, result, op, sprout::size(result));
 			}
+
+			template<typename InputIterator1, typename InputIterator2, typename Result, typename BinaryOperation>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, Result const& result, BinaryOperation op) {
+				typedef typename sprout::common_iterator_category<InputIterator1, InputIterator2>::type* category;
+				return sprout::fixed::detail::transform(first1, last1, first2, result, op, category());
+			}
+
+			template<typename InputIterator1, typename InputIterator2, typename Result, typename BinaryOperation>
+			inline SPROUT_CONSTEXPR typename std::enable_if<
+				!sprout::is_fixed_container<Result>::value,
+				typename sprout::fixed::result_of::algorithm<Result>::type
+			>::type
+			transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, Result const& result, BinaryOperation op) {
+				return sprout::remake<Result>(
+					result,
+					sprout::size(result),
+					sprout::make_transform_iterator(first1, first2, op),
+					sprout::make_transform_iterator(last1, first2, op)
+					);
+			}
 		}	// namespace detail
 		//
 		// transform
@@ -189,8 +245,13 @@ namespace sprout {
 		template<typename InputIterator1, typename InputIterator2, typename Result, typename BinaryOperation>
 		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
 		transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, Result const& result, BinaryOperation op) {
-			typedef typename std::iterator_traits<InputIterator1>::iterator_category* category;
-			return sprout::fixed::detail::transform(first1, last1, first2, result, op, category());
+			return sprout::fixed::detail::transform(first1, last1, first2, result, op);
+		}
+
+		template<typename Result, typename InputIterator1, typename InputIterator2, typename BinaryOperation>
+		inline SPROUT_CONSTEXPR typename sprout::fixed::result_of::algorithm<Result>::type
+		transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryOperation op) {
+			return sprout::fixed::transform(first1, last1, first2, sprout::pit<Result>(), op);
 		}
 	}	// namespace fixed