diff --git a/sprout/generator/generated_value.hpp b/sprout/generator/generated_value.hpp
index fe535ea3..cfb82086 100644
--- a/sprout/generator/generated_value.hpp
+++ b/sprout/generator/generated_value.hpp
@@ -7,29 +7,10 @@
 #include <sprout/type_traits/enabler_if.hpp>
 #include <sprout/tuple/tuple/get.hpp>
 
-namespace sprout {
-	namespace generators {
-		void generated_value();
-	}	// namespace generators
-}	// namespace sprout
-
 namespace sprout_generator_detail {
-	using sprout::tuples::get;
+	struct not_found_adl_generated_value {};
 
-	template<typename T>
-	struct has_spr_generated_value_test {
-	public:
-		template<
-			typename U = T,
-			typename = decltype(sprout::generators::generated_value(std::declval<U>()))
-		>
-		static std::true_type test(int);
-		static std::false_type test(...);
-	};
-	template<typename T>
-	struct has_spr_generated_value
-		: public decltype(sprout_generator_detail::has_spr_generated_value_test<T>::test(0))
-	{};
+	sprout_generator_detail::not_found_adl_generated_value generated_value(...);
 
 	template<typename T>
 	struct has_mem_generated_value_test {
@@ -46,12 +27,29 @@ namespace sprout_generator_detail {
 		: public decltype(sprout_generator_detail::has_mem_generated_value_test<T>::test(0))
 	{};
 
+	template<typename T>
+	struct has_adl_generated_value_test {
+	public:
+		template<
+			typename U = T,
+			typename sprout::enabler_if<
+				!std::is_same<decltype(generated_value(std::declval<U>())), sprout_generator_detail::not_found_adl_generated_value>::value
+			>::type = sprout::enabler
+		>
+		static std::true_type test(int);
+		static std::false_type test(...);
+	};
+	template<typename T>
+	struct has_adl_generated_value
+		: public decltype(sprout_generator_detail::has_adl_generated_value_test<T>::test(0))
+	{};
+
 	template<typename T>
 	struct has_tuple_get_generated_value_test {
 	public:
 		template<
 			typename U = T,
-			typename = decltype(get<0>(std::declval<U>()))
+			typename = decltype(sprout::tuples::get<0>(std::declval<U>()))
 		>
 		static std::true_type test(int);
 		static std::false_type test(...);
@@ -62,40 +60,40 @@ namespace sprout_generator_detail {
 	{};
 
 	template<typename T, typename Enable = void>
-	struct select_spr_generated_value;
+	struct select_mem_generated_value;
 	template<typename T>
-	struct select_spr_generated_value<
+	struct select_mem_generated_value<
 		T,
-		typename std::enable_if<sprout_generator_detail::has_spr_generated_value<T>::value>::type
+		typename std::enable_if<sprout_generator_detail::has_mem_generated_value<T>::value>::type
 	>
 		: public std::true_type
 	{};
 	template<typename T>
-	struct select_spr_generated_value<
+	struct select_mem_generated_value<
 		T,
-		typename std::enable_if<!sprout_generator_detail::has_spr_generated_value<T>::value>::type
+		typename std::enable_if<!sprout_generator_detail::has_mem_generated_value<T>::value>::type
 	>
 		: public std::false_type
 	{};
 
 	template<typename T, typename Enable = void>
-	struct select_mem_generated_value;
+	struct select_adl_generated_value;
 	template<typename T>
-	struct select_mem_generated_value<
+	struct select_adl_generated_value<
 		T,
 		typename std::enable_if<
-			sprout_generator_detail::has_mem_generated_value<T>::value
-			&& !sprout_generator_detail::has_spr_generated_value<T>::value
+			sprout_generator_detail::has_adl_generated_value<T>::value
+			&& !sprout_generator_detail::has_mem_generated_value<T>::value
 		>::type
 	>
 		: public std::true_type
 	{};
 	template<typename T>
-	struct select_mem_generated_value<
+	struct select_adl_generated_value<
 		T,
 		typename std::enable_if<!(
-			sprout_generator_detail::has_mem_generated_value<T>::value
-			&& !sprout_generator_detail::has_spr_generated_value<T>::value
+			sprout_generator_detail::has_adl_generated_value<T>::value
+			&& !sprout_generator_detail::has_mem_generated_value<T>::value
 		)>::type
 	>
 		: public std::false_type
@@ -108,8 +106,8 @@ namespace sprout_generator_detail {
 		T,
 		typename std::enable_if<
 			sprout_generator_detail::has_tuple_get_generated_value<T>::value
-			&& !sprout_generator_detail::has_spr_generated_value<T>::value
 			&& !sprout_generator_detail::has_mem_generated_value<T>::value
+			&& !sprout_generator_detail::has_adl_generated_value<T>::value
 		>::type
 	>
 		: public std::true_type
@@ -119,8 +117,8 @@ namespace sprout_generator_detail {
 		T,
 		typename std::enable_if<!(
 			sprout_generator_detail::has_tuple_get_generated_value<T>::value
-			&& !sprout_generator_detail::has_spr_generated_value<T>::value
 			&& !sprout_generator_detail::has_mem_generated_value<T>::value
+			&& !sprout_generator_detail::has_adl_generated_value<T>::value
 		)>::type
 	>
 		: public std::false_type
@@ -128,47 +126,37 @@ namespace sprout_generator_detail {
 
 	template<typename T, typename = void>
 	struct noexcept_generated_value;
-//	template<typename T>
-//	struct noexcept_generated_value<T, typename std::enable_if<sprout_generator_detail::select_spr_generated_value<T>::value>::type>
-//		: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(sprout::generators::generated_value(std::declval<T>()), false)>
-//	{};
 	template<typename T>
 	struct noexcept_generated_value<T, typename std::enable_if<sprout_generator_detail::select_mem_generated_value<T>::value>::type>
 		: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(std::declval<T>().generated_value(), false)>
 	{};
 	template<typename T>
+	struct noexcept_generated_value<T, typename std::enable_if<sprout_generator_detail::select_adl_generated_value<T>::value>::type>
+		: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(generated_value(std::declval<T>()), false)>
+	{};
+	template<typename T>
 	struct noexcept_generated_value<T, typename std::enable_if<sprout_generator_detail::select_tuple_get_generated_value<T>::value>::type>
-		: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(get<0>(std::declval<T>()), false)>
+		: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(sprout::tuples::get<0>(std::declval<T>()), false)>
 	{};
 
 	template<typename T, typename = void>
 	struct generated_value_result;
-//	template<typename T>
-//	struct generated_value_result<T, typename std::enable_if<sprout_generator_detail::select_spr_generated_value<T>::value>::type> {
-//	public:
-//		typedef decltype(sprout::generators::generated_value(std::declval<T>())) type;
-//	};
 	template<typename T>
 	struct generated_value_result<T, typename std::enable_if<sprout_generator_detail::select_mem_generated_value<T>::value>::type> {
 	public:
 		typedef decltype(std::declval<T>().generated_value()) type;
 	};
 	template<typename T>
+	struct generated_value_result<T, typename std::enable_if<sprout_generator_detail::select_adl_generated_value<T>::value>::type> {
+	public:
+		typedef decltype(generated_value(std::declval<T>())) type;
+	};
+	template<typename T>
 	struct generated_value_result<T, typename std::enable_if<sprout_generator_detail::select_tuple_get_generated_value<T>::value>::type> {
 	public:
-		typedef decltype(get<0>(std::declval<T>())) type;
+		typedef decltype(sprout::tuples::get<0>(std::declval<T>())) type;
 	};
 
-//	template<
-//		typename T,
-//		typename sprout::enabler_if<sprout_generator_detail::select_spr_generated_value<T>::value>::type = sprout::enabler
-//	>
-//	inline SPROUT_CONSTEXPR typename sprout_generator_detail::generated_value_result<T>::type
-//	generated_value_impl(T&& t)
-//		SPROUT_NOEXCEPT_EXPR((sprout_generator_detail::noexcept_generated_value<T>::value))
-//	{
-//		return sprout::generators::generated_value(sprout::forward<T>(t));
-//	}
 	template<
 		typename T,
 		typename sprout::enabler_if<sprout_generator_detail::select_mem_generated_value<T>::value>::type = sprout::enabler
@@ -179,6 +167,16 @@ namespace sprout_generator_detail {
 	{
 		return sprout::forward<T>(t).generated_value();
 	}
+	template<
+		typename T,
+		typename sprout::enabler_if<sprout_generator_detail::select_adl_generated_value<T>::value>::type = sprout::enabler
+	>
+	inline SPROUT_CONSTEXPR typename sprout_generator_detail::generated_value_result<T>::type
+	generated_value_impl(T&& t)
+		SPROUT_NOEXCEPT_EXPR((sprout_generator_detail::noexcept_generated_value<T>::value))
+	{
+		return generated_value(sprout::forward<T>(t));
+	}
 	template<
 		typename T,
 		typename sprout::enabler_if<sprout_generator_detail::select_tuple_get_generated_value<T>::value>::type = sprout::enabler
@@ -187,7 +185,7 @@ namespace sprout_generator_detail {
 	generated_value_impl(T&& t)
 		SPROUT_NOEXCEPT_EXPR((sprout_generator_detail::noexcept_generated_value<T>::value))
 	{
-		return get<0>(sprout::forward<T>(t));
+		return sprout::tuples::get<0>(sprout::forward<T>(t));
 	}
 }	// namespace sprout_generator_detail
 
diff --git a/sprout/generator/next_generator.hpp b/sprout/generator/next_generator.hpp
index d7fd733a..fcefd395 100644
--- a/sprout/generator/next_generator.hpp
+++ b/sprout/generator/next_generator.hpp
@@ -7,29 +7,10 @@
 #include <sprout/type_traits/enabler_if.hpp>
 #include <sprout/tuple/tuple/get.hpp>
 
-namespace sprout {
-	namespace generators {
-		void next_generator();
-	}	// namespace generators
-}	// namespace sprout
-
 namespace sprout_generator_detail {
-	using sprout::tuples::get;
+	struct not_found_adl_next_generator {};
 
-	template<typename T>
-	struct has_spr_next_generator_test {
-	public:
-		template<
-			typename U = T,
-			typename = decltype(sprout::generators::next_generator(std::declval<U>()))
-		>
-		static std::true_type test(int);
-		static std::false_type test(...);
-	};
-	template<typename T>
-	struct has_spr_next_generator
-		: public decltype(sprout_generator_detail::has_spr_next_generator_test<T>::test(0))
-	{};
+	sprout_generator_detail::not_found_adl_next_generator next_generator(...);
 
 	template<typename T>
 	struct has_mem_next_generator_test {
@@ -46,12 +27,29 @@ namespace sprout_generator_detail {
 		: public decltype(sprout_generator_detail::has_mem_next_generator_test<T>::test(0))
 	{};
 
+	template<typename T>
+	struct has_adl_next_generator_test {
+	public:
+		template<
+			typename U = T,
+			typename sprout::enabler_if<
+				!std::is_same<decltype(next_generator(std::declval<U>())), sprout_generator_detail::not_found_adl_next_generator>::value
+			>::type = sprout::enabler
+		>
+		static std::true_type test(int);
+		static std::false_type test(...);
+	};
+	template<typename T>
+	struct has_adl_next_generator
+		: public decltype(sprout_generator_detail::has_adl_next_generator_test<T>::test(0))
+	{};
+
 	template<typename T>
 	struct has_tuple_get_next_generator_test {
 	public:
 		template<
 			typename U = T,
-			typename = decltype(get<1>(std::declval<U>()))
+			typename = decltype(sprout::tuples::get<1>(std::declval<U>()))
 		>
 		static std::true_type test(int);
 		static std::false_type test(...);
@@ -62,40 +60,40 @@ namespace sprout_generator_detail {
 	{};
 
 	template<typename T, typename Enable = void>
-	struct select_spr_next_generator;
+	struct select_mem_next_generator;
 	template<typename T>
-	struct select_spr_next_generator<
+	struct select_mem_next_generator<
 		T,
-		typename std::enable_if<sprout_generator_detail::has_spr_next_generator<T>::value>::type
+		typename std::enable_if<sprout_generator_detail::has_mem_next_generator<T>::value>::type
 	>
 		: public std::true_type
 	{};
 	template<typename T>
-	struct select_spr_next_generator<
+	struct select_mem_next_generator<
 		T,
-		typename std::enable_if<!sprout_generator_detail::has_spr_next_generator<T>::value>::type
+		typename std::enable_if<!sprout_generator_detail::has_mem_next_generator<T>::value>::type
 	>
 		: public std::false_type
 	{};
 
 	template<typename T, typename Enable = void>
-	struct select_mem_next_generator;
+	struct select_adl_next_generator;
 	template<typename T>
-	struct select_mem_next_generator<
+	struct select_adl_next_generator<
 		T,
 		typename std::enable_if<
-			sprout_generator_detail::has_mem_next_generator<T>::value
-			&& !sprout_generator_detail::has_spr_next_generator<T>::value
+			sprout_generator_detail::has_adl_next_generator<T>::value
+			&& !sprout_generator_detail::has_mem_next_generator<T>::value
 		>::type
 	>
 		: public std::true_type
 	{};
 	template<typename T>
-	struct select_mem_next_generator<
+	struct select_adl_next_generator<
 		T,
 		typename std::enable_if<!(
-			sprout_generator_detail::has_mem_next_generator<T>::value
-			&& !sprout_generator_detail::has_spr_next_generator<T>::value
+			sprout_generator_detail::has_adl_next_generator<T>::value
+			&& !sprout_generator_detail::has_mem_next_generator<T>::value
 		)>::type
 	>
 		: public std::false_type
@@ -108,8 +106,8 @@ namespace sprout_generator_detail {
 		T,
 		typename std::enable_if<
 			sprout_generator_detail::has_tuple_get_next_generator<T>::value
-			&& !sprout_generator_detail::has_spr_next_generator<T>::value
 			&& !sprout_generator_detail::has_mem_next_generator<T>::value
+			&& !sprout_generator_detail::has_adl_next_generator<T>::value
 		>::type
 	>
 		: public std::true_type
@@ -119,8 +117,8 @@ namespace sprout_generator_detail {
 		T,
 		typename std::enable_if<!(
 			sprout_generator_detail::has_tuple_get_next_generator<T>::value
-			&& !sprout_generator_detail::has_spr_next_generator<T>::value
 			&& !sprout_generator_detail::has_mem_next_generator<T>::value
+			&& !sprout_generator_detail::has_adl_next_generator<T>::value
 		)>::type
 	>
 		: public std::false_type
@@ -128,47 +126,37 @@ namespace sprout_generator_detail {
 
 	template<typename T, typename = void>
 	struct noexcept_next_generator;
-//	template<typename T>
-//	struct noexcept_next_generator<T, typename std::enable_if<sprout_generator_detail::select_spr_next_generator<T>::value>::type>
-//		: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(sprout::generators::next_generator(std::declval<T>()), false)>
-//	{};
 	template<typename T>
 	struct noexcept_next_generator<T, typename std::enable_if<sprout_generator_detail::select_mem_next_generator<T>::value>::type>
 		: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(std::declval<T>().next_generator(), false)>
 	{};
 	template<typename T>
+	struct noexcept_next_generator<T, typename std::enable_if<sprout_generator_detail::select_adl_next_generator<T>::value>::type>
+		: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(next_generator(std::declval<T>()), false)>
+	{};
+	template<typename T>
 	struct noexcept_next_generator<T, typename std::enable_if<sprout_generator_detail::select_tuple_get_next_generator<T>::value>::type>
-		: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(get<1>(std::declval<T>()), false)>
+		: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(sprout::tuples::get<1>(std::declval<T>()), false)>
 	{};
 
 	template<typename T, typename = void>
 	struct next_generator_result;
-//	template<typename T>
-//	struct next_generator_result<T, typename std::enable_if<sprout_generator_detail::select_spr_next_generator<T>::value>::type> {
-//	public:
-//		typedef decltype(sprout::generators::next_generator(std::declval<T>())) type;
-//	};
 	template<typename T>
 	struct next_generator_result<T, typename std::enable_if<sprout_generator_detail::select_mem_next_generator<T>::value>::type> {
 	public:
 		typedef decltype(std::declval<T>().next_generator()) type;
 	};
 	template<typename T>
+	struct next_generator_result<T, typename std::enable_if<sprout_generator_detail::select_adl_next_generator<T>::value>::type> {
+	public:
+		typedef decltype(next_generator(std::declval<T>())) type;
+	};
+	template<typename T>
 	struct next_generator_result<T, typename std::enable_if<sprout_generator_detail::select_tuple_get_next_generator<T>::value>::type> {
 	public:
-		typedef decltype(get<1>(std::declval<T>())) type;
+		typedef decltype(sprout::tuples::get<1>(std::declval<T>())) type;
 	};
 
-//	template<
-//		typename T,
-//		typename sprout::enabler_if<sprout_generator_detail::select_spr_next_generator<T>::value>::type = sprout::enabler
-//	>
-//	inline SPROUT_CONSTEXPR typename sprout_generator_detail::next_generator_result<T>::type
-//	next_generator_impl(T&& t)
-//		SPROUT_NOEXCEPT_EXPR((sprout_generator_detail::noexcept_next_generator<T>::value))
-//	{
-//		return sprout::generators::next_generator(sprout::forward<T>(t));
-//	}
 	template<
 		typename T,
 		typename sprout::enabler_if<sprout_generator_detail::select_mem_next_generator<T>::value>::type = sprout::enabler
@@ -179,6 +167,16 @@ namespace sprout_generator_detail {
 	{
 		return sprout::forward<T>(t).next_generator();
 	}
+	template<
+		typename T,
+		typename sprout::enabler_if<sprout_generator_detail::select_adl_next_generator<T>::value>::type = sprout::enabler
+	>
+	inline SPROUT_CONSTEXPR typename sprout_generator_detail::next_generator_result<T>::type
+	next_generator_impl(T&& t)
+		SPROUT_NOEXCEPT_EXPR((sprout_generator_detail::noexcept_next_generator<T>::value))
+	{
+		return next_generator(sprout::forward<T>(t));
+	}
 	template<
 		typename T,
 		typename sprout::enabler_if<sprout_generator_detail::select_tuple_get_next_generator<T>::value>::type = sprout::enabler
@@ -187,7 +185,7 @@ namespace sprout_generator_detail {
 	next_generator_impl(T&& t)
 		SPROUT_NOEXCEPT_EXPR((sprout_generator_detail::noexcept_next_generator<T>::value))
 	{
-		return get<1>(sprout::forward<T>(t));
+		return sprout::tuples::get<1>(sprout::forward<T>(t));
 	}
 }	// namespace sprout_generator_detail
 
diff --git a/sprout/iterator/bytes_iterator.hpp b/sprout/iterator/bytes_iterator.hpp
index 0e7db44d..38493f3c 100644
--- a/sprout/iterator/bytes_iterator.hpp
+++ b/sprout/iterator/bytes_iterator.hpp
@@ -183,11 +183,11 @@ namespace sprout {
 	}
 
 	//
-	// distance
+	// iterator_distance
 	//
 	template<typename Iterator, typename Traits>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::bytes_iterator<Iterator, Traits> >::difference_type
-	distance(
+	iterator_distance(
 		sprout::bytes_iterator<Iterator, Traits> first,
 		sprout::bytes_iterator<Iterator, Traits> last
 		)
diff --git a/sprout/iterator/counting_iterator.hpp b/sprout/iterator/counting_iterator.hpp
index 71506c4d..06d07838 100644
--- a/sprout/iterator/counting_iterator.hpp
+++ b/sprout/iterator/counting_iterator.hpp
@@ -191,11 +191,11 @@ namespace sprout {
 	}
 
 	//
-	// distance
+	// iterator_distance
 	//
 	template<typename Incrementable>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::counting_iterator<Incrementable> >::difference_type
-	distance(
+	iterator_distance(
 		sprout::counting_iterator<Incrementable> first,
 		sprout::counting_iterator<Incrementable> last
 		)
diff --git a/sprout/iterator/distance.hpp b/sprout/iterator/distance.hpp
index 88029efd..fb737027 100644
--- a/sprout/iterator/distance.hpp
+++ b/sprout/iterator/distance.hpp
@@ -6,30 +6,36 @@
 #include <sprout/iterator/next.hpp>
 
 namespace sprout {
-	namespace detail {
+	namespace iterator_detail {
 		// Copyright (C) 2011 RiSK (sscrisk)
 
 		template<typename InputIterator>
 		inline SPROUT_CONSTEXPR typename std::iterator_traits<InputIterator>::difference_type
-		distance(InputIterator first, InputIterator last) {
+		iterator_distance(InputIterator first, InputIterator last) {
 			return first == last ? 0
-				: 1 + sprout::detail::distance(sprout::next(first), last)
+				: 1 + sprout::iterator_detail::iterator_distance(sprout::next(first), last)
 				;
 		}
-		template<typename InputIterator>
-		inline SPROUT_CONSTEXPR typename std::iterator_traits<InputIterator>::difference_type
-		distance_impl(InputIterator first, InputIterator last) {
-			using sprout::detail::distance;
-			return distance(first, last);
-		}
-	}	// namespace detail
+	}	// namespace iterator_detail
+}	// namespace sprout
+
+namespace sprout_iterator_detail {
+	template<typename InputIterator>
+	inline SPROUT_CONSTEXPR typename std::iterator_traits<InputIterator>::difference_type
+	distance(InputIterator first, InputIterator last) {
+		using sprout::iterator_detail::iterator_distance;
+		return iterator_distance(first, last);
+	}
+}	// namespace sprout_iterator_detail
+
+namespace sprout {
 	//
 	// distance
 	//
 	template<typename InputIterator>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<InputIterator>::difference_type
 	distance(InputIterator first, InputIterator last) {
-		return sprout::detail::distance_impl(first, last);
+		return sprout_iterator_detail::distance(first, last);
 	}
 }	// namespace sprout
 
diff --git a/sprout/iterator/index_iterator.hpp b/sprout/iterator/index_iterator.hpp
index 4339acab..2531887b 100644
--- a/sprout/iterator/index_iterator.hpp
+++ b/sprout/iterator/index_iterator.hpp
@@ -196,11 +196,11 @@ namespace sprout {
 	{};
 
 	//
-	// distance
+	// iterator_distance
 	//
 	template<typename Container>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::index_iterator<Container> >::difference_type
-	distance(
+	iterator_distance(
 		sprout::index_iterator<Container> first,
 		sprout::index_iterator<Container> last
 		)
diff --git a/sprout/iterator/reverse_iterator.hpp b/sprout/iterator/reverse_iterator.hpp
index 0b1a3d93..08a5ac41 100644
--- a/sprout/iterator/reverse_iterator.hpp
+++ b/sprout/iterator/reverse_iterator.hpp
@@ -200,11 +200,11 @@ namespace sprout {
 	}
 
 	//
-	// distance
+	// iterator_distance
 	//
 	template<typename Iterator>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::reverse_iterator<Iterator> >::difference_type
-	distance(
+	iterator_distance(
 		sprout::reverse_iterator<Iterator> first,
 		sprout::reverse_iterator<Iterator> last
 		)
diff --git a/sprout/iterator/sawtooth_iterator.hpp b/sprout/iterator/sawtooth_iterator.hpp
index d225f0f1..0c215348 100644
--- a/sprout/iterator/sawtooth_iterator.hpp
+++ b/sprout/iterator/sawtooth_iterator.hpp
@@ -219,11 +219,11 @@ namespace sprout {
 	}
 
 	//
-	// distance
+	// iterator_distance
 	//
 	template<typename Value>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::sawtooth_iterator<Value> >::difference_type
-	distance(
+	iterator_distance(
 		sprout::sawtooth_iterator<Value> first,
 		sprout::sawtooth_iterator<Value> last
 		)
diff --git a/sprout/iterator/sinusoid_iterator.hpp b/sprout/iterator/sinusoid_iterator.hpp
index df8e6d44..98640621 100644
--- a/sprout/iterator/sinusoid_iterator.hpp
+++ b/sprout/iterator/sinusoid_iterator.hpp
@@ -228,11 +228,11 @@ namespace sprout {
 	}
 
 	//
-	// distance
+	// iterator_distance
 	//
 	template<typename Value>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::sinusoid_iterator<Value> >::difference_type
-	distance(
+	iterator_distance(
 		sprout::sinusoid_iterator<Value> first,
 		sprout::sinusoid_iterator<Value> last
 		)
diff --git a/sprout/iterator/size_enum_iterator.hpp b/sprout/iterator/size_enum_iterator.hpp
index 5635d544..8f2489c4 100644
--- a/sprout/iterator/size_enum_iterator.hpp
+++ b/sprout/iterator/size_enum_iterator.hpp
@@ -393,11 +393,11 @@ namespace sprout {
 	}
 
 	//
-	// distance
+	// iterator_distance
 	//
 	template<typename Iterator, bool Separated>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::size_enum_iterator<Iterator, Separated> >::difference_type
-	distance(
+	iterator_distance(
 		sprout::size_enum_iterator<Iterator, Separated> first,
 		sprout::size_enum_iterator<Iterator, Separated> last
 		)
diff --git a/sprout/iterator/square_iterator.hpp b/sprout/iterator/square_iterator.hpp
index a59bb3e9..83a936e3 100644
--- a/sprout/iterator/square_iterator.hpp
+++ b/sprout/iterator/square_iterator.hpp
@@ -229,11 +229,11 @@ namespace sprout {
 	}
 
 	//
-	// distance
+	// iterator_distance
 	//
 	template<typename Value>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::square_iterator<Value> >::difference_type
-	distance(
+	iterator_distance(
 		sprout::square_iterator<Value> first,
 		sprout::square_iterator<Value> last
 		)
diff --git a/sprout/iterator/transform_iterator.hpp b/sprout/iterator/transform_iterator.hpp
index 7b0bed94..65b81a61 100644
--- a/sprout/iterator/transform_iterator.hpp
+++ b/sprout/iterator/transform_iterator.hpp
@@ -387,11 +387,11 @@ namespace sprout {
 	}
 
 	//
-	// distance
+	// iterator_distance
 	//
 	template<typename UnaryOrBinaryFunction, typename LIterator, typename RIterator>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::transform_iterator<UnaryOrBinaryFunction, LIterator, RIterator> >::difference_type
-	distance(
+	iterator_distance(
 		sprout::transform_iterator<UnaryOrBinaryFunction, LIterator, RIterator> first,
 		sprout::transform_iterator<UnaryOrBinaryFunction, LIterator, RIterator> last
 		)
diff --git a/sprout/iterator/triangle_iterator.hpp b/sprout/iterator/triangle_iterator.hpp
index 22b9ea9d..e1c31049 100644
--- a/sprout/iterator/triangle_iterator.hpp
+++ b/sprout/iterator/triangle_iterator.hpp
@@ -219,11 +219,11 @@ namespace sprout {
 	}
 
 	//
-	// distance
+	// iterator_distance
 	//
 	template<typename Value>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::triangle_iterator<Value> >::difference_type
-	distance(
+	iterator_distance(
 		sprout::triangle_iterator<Value> first,
 		sprout::triangle_iterator<Value> last
 		)
diff --git a/sprout/iterator/value_iterator.hpp b/sprout/iterator/value_iterator.hpp
index c5b1f0cd..e83312c7 100644
--- a/sprout/iterator/value_iterator.hpp
+++ b/sprout/iterator/value_iterator.hpp
@@ -165,11 +165,11 @@ namespace sprout {
 	}
 
 	//
-	// distance
+	// iterator_distance
 	//
 	template<typename T>
 	inline SPROUT_CONSTEXPR typename std::iterator_traits<sprout::value_iterator<T> >::difference_type
-	distance(sprout::value_iterator<T> first, sprout::value_iterator<T> last) {
+	iterator_distance(sprout::value_iterator<T> first, sprout::value_iterator<T> last) {
 		return last - first;
 	}
 
diff --git a/sprout/random/random_result.hpp b/sprout/random/random_result.hpp
index f7000778..7c5f66e3 100644
--- a/sprout/random/random_result.hpp
+++ b/sprout/random/random_result.hpp
@@ -187,12 +187,24 @@ namespace sprout {
 			SPROUT_CONSTEXPR result_type const& result() const {
 				return result_;
 			}
+			result_type& generated_value() {
+				return result_;
+			}
+			SPROUT_CONSTEXPR result_type const& generated_value() const {
+				return result_;
+			}
 			engine_type& engine() {
 				return engine_;
 			}
 			SPROUT_CONSTEXPR engine_type const& engine() const {
 				return engine_;
 			}
+			engine_type& next_generator() {
+				return engine_;
+			}
+			SPROUT_CONSTEXPR engine_type const& next_generator() const {
+				return engine_;
+			}
 			SPROUT_CONSTEXPR result_type min() const {
 				return engine_.min();
 			}
@@ -244,15 +256,41 @@ namespace sprout {
 		}
 
 		//
-		// next
+		// iterator_next
 		//
 		template<typename Engine, typename Distribution>
-		SPROUT_CONSTEXPR sprout::random::random_result<Engine, Distribution> next(
-			sprout::random::random_result<Engine, Distribution> const& it
-			)
-		{
+		SPROUT_CONSTEXPR sprout::random::random_result<Engine, Distribution>
+		iterator_next(sprout::random::random_result<Engine, Distribution> const& it) {
 			return it();
 		}
+
+		//
+		// generated_value
+		//
+		template<typename Engine, typename Distribution>
+		inline SPROUT_CONSTEXPR typename sprout::random::random_result<Engine, Distribution>::result_type const&
+		generated_value(sprout::random::random_result<Engine, Distribution> const& t) {
+			return t.generated_value();
+		}
+		template<typename Engine, typename Distribution>
+		inline typename sprout::random::random_result<Engine, Distribution>::result_type&
+		generated_value(sprout::random::random_result<Engine, Distribution>& t) {
+			return t.generated_value();
+		}
+
+		//
+		// next_generator
+		//
+		template<typename Engine, typename Distribution>
+		inline SPROUT_CONSTEXPR typename sprout::random::random_result<Engine, Distribution>::engine_type const&
+		next_generator(sprout::random::random_result<Engine, Distribution> const& t) {
+			return t.next_generator();
+		}
+		template<typename Engine, typename Distribution>
+		inline typename sprout::random::random_result<Engine, Distribution>::engine_type&
+		next_generator(sprout::random::random_result<Engine, Distribution>& t) {
+			return t.next_generator();
+		}
 	}	// namespace random
 
 	using sprout::random::random_result;